text: (function(scope){
  'use strict';
  
  function F(arity, fun, wrapper) {
    wrapper.a = arity;
    wrapper.f = fun;
    return wrapper;
  }
  
  function F2(fun) {
    return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })
  }
  function F3(fun) {
    return F(3, fun, function(a) {
      return function(b) { return function(c) { return fun(a, b, c); }; };
    });
  }
  function F4(fun) {
    return F(4, fun, function(a) { return function(b) { return function(c) {
      return function(d) { return fun(a, b, c, d); }; }; };
    });
  }
  function F5(fun) {
    return F(5, fun, function(a) { return function(b) { return function(c) {
      return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };
    });
  }
  function F6(fun) {
    return F(6, fun, function(a) { return function(b) { return function(c) {
      return function(d) { return function(e) { return function(f) {
      return fun(a, b, c, d, e, f); }; }; }; }; };
    });
  }
  function F7(fun) {
    return F(7, fun, function(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); }; }; }; }; }; };
    });
  }
  function F8(fun) {
    return F(8, fun, function(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); }; }; }; }; }; }; };
    });
  }
  function F9(fun) {
    return F(9, fun, function(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); }; }; }; }; }; }; }; };
    });
  }
  
  function A2(fun, a, b) {
    return fun.a === 2 ? fun.f(a, b) : fun(a)(b);
  }
  function A3(fun, a, b, c) {
    return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);
  }
  function A4(fun, a, b, c, d) {
    return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);
  }
  function A5(fun, a, b, c, d, e) {
    return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);
  }
  function A6(fun, a, b, c, d, e, f) {
    return fun.a === 6 ? fun.f(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.a === 7 ? fun.f(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.a === 8 ? fun.f(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.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);
  }
  
  
  
  
  // EQUALITY
  
  function _Utils_eq(x, y)
  {
  	for (
  		var pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);
  		isEqual && (pair = stack.pop());
  		isEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)
  		)
  	{}
  
  	return isEqual;
  }
  
  function _Utils_eqHelp(x, y, depth, stack)
  {
  	if (x === y)
  	{
  		return true;
  	}
  
  	if (typeof x !== 'object' || x === null || y === null)
  	{
  		typeof x === 'function' && _Debug_crash(5);
  		return false;
  	}
  
  	if (depth > 100)
  	{
  		stack.push(_Utils_Tuple2(x,y));
  		return true;
  	}
  
  	/**_UNUSED/
  	if (x.$ === 'Set_elm_builtin')
  	{
  		x = $elm$core$Set$toList(x);
  		y = $elm$core$Set$toList(y);
  	}
  	if (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')
  	{
  		x = $elm$core$Dict$toList(x);
  		y = $elm$core$Dict$toList(y);
  	}
  	//*/
  
  	/**/
  	if (x.$ < 0)
  	{
  		x = $elm$core$Dict$toList(x);
  		y = $elm$core$Dict$toList(y);
  	}
  	//*/
  
  	for (var key in x)
  	{
  		if (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))
  		{
  			return false;
  		}
  	}
  	return true;
  }
  
  var _Utils_equal = F2(_Utils_eq);
  var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });
  
  
  
  // COMPARISONS
  
  // Code in Generate/JavaScript.hs, Basics.js, and List.js depends on
  // the particular integer values assigned to LT, EQ, and GT.
  
  function _Utils_cmp(x, y, ord)
  {
  	if (typeof x !== 'object')
  	{
  		return x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;
  	}
  
  	/**_UNUSED/
  	if (x instanceof String)
  	{
  		var a = x.valueOf();
  		var b = y.valueOf();
  		return a === b ? 0 : a < b ? -1 : 1;
  	}
  	//*/
  
  	/**/
  	if (typeof x.$ === 'undefined')
  	//*/
  	/**_UNUSED/
  	if (x.$[0] === '#')
  	//*/
  	{
  		return (ord = _Utils_cmp(x.a, y.a))
  			? ord
  			: (ord = _Utils_cmp(x.b, y.b))
  				? ord
  				: _Utils_cmp(x.c, y.c);
  	}
  
  	// traverse conses until end of a list or a mismatch
  	for (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES
  	return ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);
  }
  
  var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });
  var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });
  var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });
  var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });
  
  var _Utils_compare = F2(function(x, y)
  {
  	var n = _Utils_cmp(x, y);
  	return n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;
  });
  
  
  // COMMON VALUES
  
  var _Utils_Tuple0 = 0;
  var _Utils_Tuple0_UNUSED = { $: '#0' };
  
  function _Utils_Tuple2(a, b) { return { a: a, b: b }; }
  function _Utils_Tuple2_UNUSED(a, b) { return { $: '#2', a: a, b: b }; }
  
  function _Utils_Tuple3(a, b, c) { return { a: a, b: b, c: c }; }
  function _Utils_Tuple3_UNUSED(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }
  
  function _Utils_chr(c) { return c; }
  function _Utils_chr_UNUSED(c) { return new String(c); }
  
  
  // RECORDS
  
  function _Utils_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;
  }
  
  
  // APPEND
  
  var _Utils_append = F2(_Utils_ap);
  
  function _Utils_ap(xs, ys)
  {
  	// append Strings
  	if (typeof xs === 'string')
  	{
  		return xs + ys;
  	}
  
  	// append Lists
  	if (!xs.b)
  	{
  		return ys;
  	}
  	var root = _List_Cons(xs.a, ys);
  	xs = xs.b
  	for (var curr = root; xs.b; xs = xs.b) // WHILE_CONS
  	{
  		curr = curr.b = _List_Cons(xs.a, ys);
  	}
  	return root;
  }
  
  
  
  var _List_Nil = { $: 0 };
  var _List_Nil_UNUSED = { $: '[]' };
  
  function _List_Cons(hd, tl) { return { $: 1, a: hd, b: tl }; }
  function _List_Cons_UNUSED(hd, tl) { return { $: '::', a: hd, b: tl }; }
  
  
  var _List_cons = F2(_List_Cons);
  
  function _List_fromArray(arr)
  {
  	var out = _List_Nil;
  	for (var i = arr.length; i--; )
  	{
  		out = _List_Cons(arr[i], out);
  	}
  	return out;
  }
  
  function _List_toArray(xs)
  {
  	for (var out = []; xs.b; xs = xs.b) // WHILE_CONS
  	{
  		out.push(xs.a);
  	}
  	return out;
  }
  
  var _List_map2 = F3(function(f, xs, ys)
  {
  	for (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES
  	{
  		arr.push(A2(f, xs.a, ys.a));
  	}
  	return _List_fromArray(arr);
  });
  
  var _List_map3 = F4(function(f, xs, ys, zs)
  {
  	for (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
  	{
  		arr.push(A3(f, xs.a, ys.a, zs.a));
  	}
  	return _List_fromArray(arr);
  });
  
  var _List_map4 = F5(function(f, ws, xs, ys, zs)
  {
  	for (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
  	{
  		arr.push(A4(f, ws.a, xs.a, ys.a, zs.a));
  	}
  	return _List_fromArray(arr);
  });
  
  var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)
  {
  	for (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES
  	{
  		arr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));
  	}
  	return _List_fromArray(arr);
  });
  
  var _List_sortBy = F2(function(f, xs)
  {
  	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
  		return _Utils_cmp(f(a), f(b));
  	}));
  });
  
  var _List_sortWith = F2(function(f, xs)
  {
  	return _List_fromArray(_List_toArray(xs).sort(function(a, b) {
  		var ord = A2(f, a, b);
  		return ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;
  	}));
  });
  
  
  
  var _JsArray_empty = [];
  
  function _JsArray_singleton(value)
  {
      return [value];
  }
  
  function _JsArray_length(array)
  {
      return array.length;
  }
  
  var _JsArray_initialize = F3(function(size, offset, func)
  {
      var result = new Array(size);
  
      for (var i = 0; i < size; i++)
      {
          result[i] = func(offset + i);
      }
  
      return result;
  });
  
  var _JsArray_initializeFromList = F2(function (max, ls)
  {
      var result = new Array(max);
  
      for (var i = 0; i < max && ls.b; i++)
      {
          result[i] = ls.a;
          ls = ls.b;
      }
  
      result.length = i;
      return _Utils_Tuple2(result, ls);
  });
  
  var _JsArray_unsafeGet = F2(function(index, array)
  {
      return array[index];
  });
  
  var _JsArray_unsafeSet = F3(function(index, value, array)
  {
      var length = array.length;
      var result = new Array(length);
  
      for (var i = 0; i < length; i++)
      {
          result[i] = array[i];
      }
  
      result[index] = value;
      return result;
  });
  
  var _JsArray_push = F2(function(value, array)
  {
      var length = array.length;
      var result = new Array(length + 1);
  
      for (var i = 0; i < length; i++)
      {
          result[i] = array[i];
      }
  
      result[length] = value;
      return result;
  });
  
  var _JsArray_foldl = F3(function(func, acc, array)
  {
      var length = array.length;
  
      for (var i = 0; i < length; i++)
      {
          acc = A2(func, array[i], acc);
      }
  
      return acc;
  });
  
  var _JsArray_foldr = F3(function(func, acc, array)
  {
      for (var i = array.length - 1; i >= 0; i--)
      {
          acc = A2(func, array[i], acc);
      }
  
      return acc;
  });
  
  var _JsArray_map = F2(function(func, array)
  {
      var length = array.length;
      var result = new Array(length);
  
      for (var i = 0; i < length; i++)
      {
          result[i] = func(array[i]);
      }
  
      return result;
  });
  
  var _JsArray_indexedMap = F3(function(func, offset, array)
  {
      var length = array.length;
      var result = new Array(length);
  
      for (var i = 0; i < length; i++)
      {
          result[i] = A2(func, offset + i, array[i]);
      }
  
      return result;
  });
  
  var _JsArray_slice = F3(function(from, to, array)
  {
      return array.slice(from, to);
  });
  
  var _JsArray_appendN = F3(function(n, dest, source)
  {
      var destLen = dest.length;
      var itemsToCopy = n - destLen;
  
      if (itemsToCopy > source.length)
      {
          itemsToCopy = source.length;
      }
  
      var size = destLen + itemsToCopy;
      var result = new Array(size);
  
      for (var i = 0; i < destLen; i++)
      {
          result[i] = dest[i];
      }
  
      for (var i = 0; i < itemsToCopy; i++)
      {
          result[i + destLen] = source[i];
      }
  
      return result;
  });
  
  
  
  // LOG
  
  var _Debug_log = F2(function(tag, value)
  {
  	return value;
  });
  
  var _Debug_log_UNUSED = F2(function(tag, value)
  {
  	console.log(tag + ': ' + _Debug_toString(value));
  	return value;
  });
  
  
  // TODOS
  
  function _Debug_todo(moduleName, region)
  {
  	return function(message) {
  		_Debug_crash(8, moduleName, region, message);
  	};
  }
  
  function _Debug_todoCase(moduleName, region, value)
  {
  	return function(message) {
  		_Debug_crash(9, moduleName, region, value, message);
  	};
  }
  
  
  // TO STRING
  
  function _Debug_toString(value)
  {
  	return '<internals>';
  }
  
  function _Debug_toString_UNUSED(value)
  {
  	return _Debug_toAnsiString(false, value);
  }
  
  function _Debug_toAnsiString(ansi, value)
  {
  	if (typeof value === 'function')
  	{
  		return _Debug_internalColor(ansi, '<function>');
  	}
  
  	if (typeof value === 'boolean')
  	{
  		return _Debug_ctorColor(ansi, value ? 'True' : 'False');
  	}
  
  	if (typeof value === 'number')
  	{
  		return _Debug_numberColor(ansi, value + '');
  	}
  
  	if (value instanceof String)
  	{
  		return _Debug_charColor(ansi, "'" + _Debug_addSlashes(value, true) + "'");
  	}
  
  	if (typeof value === 'string')
  	{
  		return _Debug_stringColor(ansi, '"' + _Debug_addSlashes(value, false) + '"');
  	}
  
  	if (typeof value === 'object' && '$' in value)
  	{
  		var tag = value.$;
  
  		if (typeof tag === 'number')
  		{
  			return _Debug_internalColor(ansi, '<internals>');
  		}
  
  		if (tag[0] === '#')
  		{
  			var output = [];
  			for (var k in value)
  			{
  				if (k === '$') continue;
  				output.push(_Debug_toAnsiString(ansi, value[k]));
  			}
  			return '(' + output.join(',') + ')';
  		}
  
  		if (tag === 'Set_elm_builtin')
  		{
  			return _Debug_ctorColor(ansi, 'Set')
  				+ _Debug_fadeColor(ansi, '.fromList') + ' '
  				+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));
  		}
  
  		if (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')
  		{
  			return _Debug_ctorColor(ansi, 'Dict')
  				+ _Debug_fadeColor(ansi, '.fromList') + ' '
  				+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));
  		}
  
  		if (tag === 'Array_elm_builtin')
  		{
  			return _Debug_ctorColor(ansi, 'Array')
  				+ _Debug_fadeColor(ansi, '.fromList') + ' '
  				+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));
  		}
  
  		if (tag === '::' || tag === '[]')
  		{
  			var output = '[';
  
  			value.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)
  
  			for (; value.b; value = value.b) // WHILE_CONS
  			{
  				output += ',' + _Debug_toAnsiString(ansi, value.a);
  			}
  			return output + ']';
  		}
  
  		var output = '';
  		for (var i in value)
  		{
  			if (i === '$') continue;
  			var str = _Debug_toAnsiString(ansi, value[i]);
  			var c0 = str[0];
  			var parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '"' || str.indexOf(' ') < 0;
  			output += ' ' + (parenless ? str : '(' + str + ')');
  		}
  		return _Debug_ctorColor(ansi, tag) + output;
  	}
  
  	if (typeof DataView === 'function' && value instanceof DataView)
  	{
  		return _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');
  	}
  
  	if (typeof File !== 'undefined' && value instanceof File)
  	{
  		return _Debug_internalColor(ansi, '<' + value.name + '>');
  	}
  
  	if (typeof value === 'object')
  	{
  		var output = [];
  		for (var key in value)
  		{
  			var field = key[0] === '_' ? key.slice(1) : key;
  			output.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));
  		}
  		if (output.length === 0)
  		{
  			return '{}';
  		}
  		return '{ ' + output.join(', ') + ' }';
  	}
  
  	return _Debug_internalColor(ansi, '<internals>');
  }
  
  function _Debug_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, '\\"');
  	}
  }
  
  function _Debug_ctorColor(ansi, string)
  {
  	return ansi ? '\x1b[96m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_numberColor(ansi, string)
  {
  	return ansi ? '\x1b[95m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_stringColor(ansi, string)
  {
  	return ansi ? '\x1b[93m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_charColor(ansi, string)
  {
  	return ansi ? '\x1b[92m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_fadeColor(ansi, string)
  {
  	return ansi ? '\x1b[37m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_internalColor(ansi, string)
  {
  	return ansi ? '\x1b[36m' + string + '\x1b[0m' : string;
  }
  
  function _Debug_toHexDigit(n)
  {
  	return String.fromCharCode(n < 10 ? 48 + n : 55 + n);
  }
  
  
  // CRASH
  
  
  function _Debug_crash(identifier)
  {
  	throw new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');
  }
  
  
  function _Debug_crash_UNUSED(identifier, fact1, fact2, fact3, fact4)
  {
  	switch(identifier)
  	{
  		case 0:
  			throw new Error('What node should I take over? In JavaScript I need something like:\n\n    Elm.Main.init({\n        node: document.getElementById("elm-node")\n    })\n\nYou need to do this with any Browser.sandbox or Browser.element program.');
  
  		case 1:
  			throw new Error('Browser.application programs cannot handle URLs like this:\n\n    ' + document.location.href + '\n\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');
  
  		case 2:
  			var jsonErrorString = fact1;
  			throw new Error('Problem with the flags given to your Elm program on initialization.\n\n' + jsonErrorString);
  
  		case 3:
  			var portName = fact1;
  			throw new Error('There can only be one port named `' + portName + '`, but your program has multiple.');
  
  		case 4:
  			var portName = fact1;
  			var problem = fact2;
  			throw new Error('Trying to send an unexpected type of value through port `' + portName + '`:\n' + problem);
  
  		case 5:
  			throw new Error('Trying to use `(==)` on functions.\nThere is no way to know if functions are "the same" in the Elm sense.\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');
  
  		case 6:
  			var moduleName = fact1;
  			throw new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');
  
  		case 8:
  			var moduleName = fact1;
  			var region = fact2;
  			var message = fact3;
  			throw new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\n\n' + message);
  
  		case 9:
  			var moduleName = fact1;
  			var region = fact2;
  			var value = fact3;
  			var message = fact4;
  			throw new Error(
  				'TODO in module `' + moduleName + '` from the `case` expression '
  				+ _Debug_regionToString(region) + '\n\nIt received the following value:\n\n    '
  				+ _Debug_toString(value).replace('\n', '\n    ')
  				+ '\n\nBut the branch that handles it says:\n\n    ' + message.replace('\n', '\n    ')
  			);
  
  		case 10:
  			throw new Error('Bug in https://github.com/elm/virtual-dom/issues');
  
  		case 11:
  			throw new Error('Cannot perform mod 0. Division by zero error.');
  	}
  }
  
  function _Debug_regionToString(region)
  {
  	if (region.bv.ax === region.bM.ax)
  	{
  		return 'on line ' + region.bv.ax;
  	}
  	return 'on lines ' + region.bv.ax + ' through ' + region.bM.ax;
  }
  
  
  
  // MATH
  
  var _Basics_add = F2(function(a, b) { return a + b; });
  var _Basics_sub = F2(function(a, b) { return a - b; });
  var _Basics_mul = F2(function(a, b) { return a * b; });
  var _Basics_fdiv = F2(function(a, b) { return a / b; });
  var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });
  var _Basics_pow = F2(Math.pow);
  
  var _Basics_remainderBy = F2(function(b, a) { return a % b; });
  
  // https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf
  var _Basics_modBy = F2(function(modulus, x)
  {
  	var answer = x % modulus;
  	return modulus === 0
  		? _Debug_crash(11)
  		:
  	((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))
  		? answer + modulus
  		: answer;
  });
  
  
  // TRIGONOMETRY
  
  var _Basics_pi = Math.PI;
  var _Basics_e = Math.E;
  var _Basics_cos = Math.cos;
  var _Basics_sin = Math.sin;
  var _Basics_tan = Math.tan;
  var _Basics_acos = Math.acos;
  var _Basics_asin = Math.asin;
  var _Basics_atan = Math.atan;
  var _Basics_atan2 = F2(Math.atan2);
  
  
  // MORE MATH
  
  function _Basics_toFloat(x) { return x; }
  function _Basics_truncate(n) { return n | 0; }
  function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }
  
  var _Basics_ceiling = Math.ceil;
  var _Basics_floor = Math.floor;
  var _Basics_round = Math.round;
  var _Basics_sqrt = Math.sqrt;
  var _Basics_log = Math.log;
  var _Basics_isNaN = isNaN;
  
  
  // BOOLEANS
  
  function _Basics_not(bool) { return !bool; }
  var _Basics_and = F2(function(a, b) { return a && b; });
  var _Basics_or  = F2(function(a, b) { return a || b; });
  var _Basics_xor = F2(function(a, b) { return a !== b; });
  
  
  
  var _String_cons = F2(function(chr, str)
  {
  	return chr + str;
  });
  
  function _String_uncons(string)
  {
  	var word = string.charCodeAt(0);
  	return !isNaN(word)
  		? $elm$core$Maybe$Just(
  			0xD800 <= word && word <= 0xDBFF
  				? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))
  				: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))
  		)
  		: $elm$core$Maybe$Nothing;
  }
  
  var _String_append = F2(function(a, b)
  {
  	return a + b;
  });
  
  function _String_length(str)
  {
  	return str.length;
  }
  
  var _String_map = F2(function(func, string)
  {
  	var len = string.length;
  	var array = new Array(len);
  	var i = 0;
  	while (i < len)
  	{
  		var word = string.charCodeAt(i);
  		if (0xD800 <= word && word <= 0xDBFF)
  		{
  			array[i] = func(_Utils_chr(string[i] + string[i+1]));
  			i += 2;
  			continue;
  		}
  		array[i] = func(_Utils_chr(string[i]));
  		i++;
  	}
  	return array.join('');
  });
  
  var _String_filter = F2(function(isGood, str)
  {
  	var arr = [];
  	var len = str.length;
  	var i = 0;
  	while (i < len)
  	{
  		var char = str[i];
  		var word = str.charCodeAt(i);
  		i++;
  		if (0xD800 <= word && word <= 0xDBFF)
  		{
  			char += str[i];
  			i++;
  		}
  
  		if (isGood(_Utils_chr(char)))
  		{
  			arr.push(char);
  		}
  	}
  	return arr.join('');
  });
  
  function _String_reverse(str)
  {
  	var len = str.length;
  	var arr = new Array(len);
  	var i = 0;
  	while (i < len)
  	{
  		var word = str.charCodeAt(i);
  		if (0xD800 <= word && word <= 0xDBFF)
  		{
  			arr[len - i] = str[i + 1];
  			i++;
  			arr[len - i] = str[i - 1];
  			i++;
  		}
  		else
  		{
  			arr[len - i] = str[i];
  			i++;
  		}
  	}
  	return arr.join('');
  }
  
  var _String_foldl = F3(function(func, state, string)
  {
  	var len = string.length;
  	var i = 0;
  	while (i < len)
  	{
  		var char = string[i];
  		var word = string.charCodeAt(i);
  		i++;
  		if (0xD800 <= word && word <= 0xDBFF)
  		{
  			char += string[i];
  			i++;
  		}
  		state = A2(func, _Utils_chr(char), state);
  	}
  	return state;
  });
  
  var _String_foldr = F3(function(func, state, string)
  {
  	var i = string.length;
  	while (i--)
  	{
  		var char = string[i];
  		var word = string.charCodeAt(i);
  		if (0xDC00 <= word && word <= 0xDFFF)
  		{
  			i--;
  			char = string[i] + char;
  		}
  		state = A2(func, _Utils_chr(char), state);
  	}
  	return state;
  });
  
  var _String_split = F2(function(sep, str)
  {
  	return str.split(sep);
  });
  
  var _String_join = F2(function(sep, strs)
  {
  	return strs.join(sep);
  });
  
  var _String_slice = F3(function(start, end, str) {
  	return str.slice(start, end);
  });
  
  function _String_trim(str)
  {
  	return str.trim();
  }
  
  function _String_trimLeft(str)
  {
  	return str.replace(/^\s+/, '');
  }
  
  function _String_trimRight(str)
  {
  	return str.replace(/\s+$/, '');
  }
  
  function _String_words(str)
  {
  	return _List_fromArray(str.trim().split(/\s+/g));
  }
  
  function _String_lines(str)
  {
  	return _List_fromArray(str.split(/\r\n|\r|\n/g));
  }
  
  function _String_toUpper(str)
  {
  	return str.toUpperCase();
  }
  
  function _String_toLower(str)
  {
  	return str.toLowerCase();
  }
  
  var _String_any = F2(function(isGood, string)
  {
  	var i = string.length;
  	while (i--)
  	{
  		var char = string[i];
  		var word = string.charCodeAt(i);
  		if (0xDC00 <= word && word <= 0xDFFF)
  		{
  			i--;
  			char = string[i] + char;
  		}
  		if (isGood(_Utils_chr(char)))
  		{
  			return true;
  		}
  	}
  	return false;
  });
  
  var _String_all = F2(function(isGood, string)
  {
  	var i = string.length;
  	while (i--)
  	{
  		var char = string[i];
  		var word = string.charCodeAt(i);
  		if (0xDC00 <= word && word <= 0xDFFF)
  		{
  			i--;
  			char = string[i] + char;
  		}
  		if (!isGood(_Utils_chr(char)))
  		{
  			return false;
  		}
  	}
  	return true;
  });
  
  var _String_contains = F2(function(sub, str)
  {
  	return str.indexOf(sub) > -1;
  });
  
  var _String_startsWith = F2(function(sub, str)
  {
  	return str.indexOf(sub) === 0;
  });
  
  var _String_endsWith = F2(function(sub, str)
  {
  	return str.length >= sub.length &&
  		str.lastIndexOf(sub) === str.length - sub.length;
  });
  
  var _String_indexes = F2(function(sub, str)
  {
  	var subLen = sub.length;
  
  	if (subLen < 1)
  	{
  		return _List_Nil;
  	}
  
  	var i = 0;
  	var is = [];
  
  	while ((i = str.indexOf(sub, i)) > -1)
  	{
  		is.push(i);
  		i = i + subLen;
  	}
  
  	return _List_fromArray(is);
  });
  
  
  // TO STRING
  
  function _String_fromNumber(number)
  {
  	return number + '';
  }
  
  
  // INT CONVERSIONS
  
  function _String_toInt(str)
  {
  	var total = 0;
  	var code0 = str.charCodeAt(0);
  	var start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;
  
  	for (var i = start; i < str.length; ++i)
  	{
  		var code = str.charCodeAt(i);
  		if (code < 0x30 || 0x39 < code)
  		{
  			return $elm$core$Maybe$Nothing;
  		}
  		total = 10 * total + code - 0x30;
  	}
  
  	return i == start
  		? $elm$core$Maybe$Nothing
  		: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);
  }
  
  
  // FLOAT CONVERSIONS
  
  function _String_toFloat(s)
  {
  	// check if it is a hex, octal, or binary number
  	if (s.length === 0 || /[\sxbo]/.test(s))
  	{
  		return $elm$core$Maybe$Nothing;
  	}
  	var n = +s;
  	// faster isNaN check
  	return n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;
  }
  
  function _String_fromList(chars)
  {
  	return _List_toArray(chars).join('');
  }
  
  
  
  
  function _Char_toCode(char)
  {
  	var code = char.charCodeAt(0);
  	if (0xD800 <= code && code <= 0xDBFF)
  	{
  		return (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000
  	}
  	return code;
  }
  
  function _Char_fromCode(code)
  {
  	return _Utils_chr(
  		(code < 0 || 0x10FFFF < code)
  			? '\uFFFD'
  			:
  		(code <= 0xFFFF)
  			? String.fromCharCode(code)
  			:
  		(code -= 0x10000,
  			String.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)
  		)
  	);
  }
  
  function _Char_toUpper(char)
  {
  	return _Utils_chr(char.toUpperCase());
  }
  
  function _Char_toLower(char)
  {
  	return _Utils_chr(char.toLowerCase());
  }
  
  function _Char_toLocaleUpper(char)
  {
  	return _Utils_chr(char.toLocaleUpperCase());
  }
  
  function _Char_toLocaleLower(char)
  {
  	return _Utils_chr(char.toLocaleLowerCase());
  }
  
  
  
  /**_UNUSED/
  function _Json_errorToString(error)
  {
  	return $elm$json$Json$Decode$errorToString(error);
  }
  //*/
  
  
  // CORE DECODERS
  
  function _Json_succeed(msg)
  {
  	return {
  		$: 0,
  		a: msg
  	};
  }
  
  function _Json_fail(msg)
  {
  	return {
  		$: 1,
  		a: msg
  	};
  }
  
  function _Json_decodePrim(decoder)
  {
  	return { $: 2, b: decoder };
  }
  
  var _Json_decodeInt = _Json_decodePrim(function(value) {
  	return (typeof value !== 'number')
  		? _Json_expecting('an INT', value)
  		:
  	(-2147483647 < value && value < 2147483647 && (value | 0) === value)
  		? $elm$core$Result$Ok(value)
  		:
  	(isFinite(value) && !(value % 1))
  		? $elm$core$Result$Ok(value)
  		: _Json_expecting('an INT', value);
  });
  
  var _Json_decodeBool = _Json_decodePrim(function(value) {
  	return (typeof value === 'boolean')
  		? $elm$core$Result$Ok(value)
  		: _Json_expecting('a BOOL', value);
  });
  
  var _Json_decodeFloat = _Json_decodePrim(function(value) {
  	return (typeof value === 'number')
  		? $elm$core$Result$Ok(value)
  		: _Json_expecting('a FLOAT', value);
  });
  
  var _Json_decodeValue = _Json_decodePrim(function(value) {
  	return $elm$core$Result$Ok(_Json_wrap(value));
  });
  
  var _Json_decodeString = _Json_decodePrim(function(value) {
  	return (typeof value === 'string')
  		? $elm$core$Result$Ok(value)
  		: (value instanceof String)
  			? $elm$core$Result$Ok(value + '')
  			: _Json_expecting('a STRING', value);
  });
  
  function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }
  function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }
  
  function _Json_decodeNull(value) { return { $: 5, c: value }; }
  
  var _Json_decodeField = F2(function(field, decoder)
  {
  	return {
  		$: 6,
  		d: field,
  		b: decoder
  	};
  });
  
  var _Json_decodeIndex = F2(function(index, decoder)
  {
  	return {
  		$: 7,
  		e: index,
  		b: decoder
  	};
  });
  
  function _Json_decodeKeyValuePairs(decoder)
  {
  	return {
  		$: 8,
  		b: decoder
  	};
  }
  
  function _Json_mapMany(f, decoders)
  {
  	return {
  		$: 9,
  		f: f,
  		g: decoders
  	};
  }
  
  var _Json_andThen = F2(function(callback, decoder)
  {
  	return {
  		$: 10,
  		b: decoder,
  		h: callback
  	};
  });
  
  function _Json_oneOf(decoders)
  {
  	return {
  		$: 11,
  		g: decoders
  	};
  }
  
  
  // DECODING OBJECTS
  
  var _Json_map1 = F2(function(f, d1)
  {
  	return _Json_mapMany(f, [d1]);
  });
  
  var _Json_map2 = F3(function(f, d1, d2)
  {
  	return _Json_mapMany(f, [d1, d2]);
  });
  
  var _Json_map3 = F4(function(f, d1, d2, d3)
  {
  	return _Json_mapMany(f, [d1, d2, d3]);
  });
  
  var _Json_map4 = F5(function(f, d1, d2, d3, d4)
  {
  	return _Json_mapMany(f, [d1, d2, d3, d4]);
  });
  
  var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)
  {
  	return _Json_mapMany(f, [d1, d2, d3, d4, d5]);
  });
  
  var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)
  {
  	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);
  });
  
  var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)
  {
  	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);
  });
  
  var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)
  {
  	return _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);
  });
  
  
  // DECODE
  
  var _Json_runOnString = F2(function(decoder, string)
  {
  	try
  	{
  		var value = JSON.parse(string);
  		return _Json_runHelp(decoder, value);
  	}
  	catch (e)
  	{
  		return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));
  	}
  });
  
  var _Json_run = F2(function(decoder, value)
  {
  	return _Json_runHelp(decoder, _Json_unwrap(value));
  });
  
  function _Json_runHelp(decoder, value)
  {
  	switch (decoder.$)
  	{
  		case 2:
  			return decoder.b(value);
  
  		case 5:
  			return (value === null)
  				? $elm$core$Result$Ok(decoder.c)
  				: _Json_expecting('null', value);
  
  		case 3:
  			if (!_Json_isArray(value))
  			{
  				return _Json_expecting('a LIST', value);
  			}
  			return _Json_runArrayDecoder(decoder.b, value, _List_fromArray);
  
  		case 4:
  			if (!_Json_isArray(value))
  			{
  				return _Json_expecting('an ARRAY', value);
  			}
  			return _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);
  
  		case 6:
  			var field = decoder.d;
  			if (typeof value !== 'object' || value === null || !(field in value))
  			{
  				return _Json_expecting('an OBJECT with a field named `' + field + '`', value);
  			}
  			var result = _Json_runHelp(decoder.b, value[field]);
  			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));
  
  		case 7:
  			var index = decoder.e;
  			if (!_Json_isArray(value))
  			{
  				return _Json_expecting('an ARRAY', value);
  			}
  			if (index >= value.length)
  			{
  				return _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);
  			}
  			var result = _Json_runHelp(decoder.b, value[index]);
  			return ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));
  
  		case 8:
  			if (typeof value !== 'object' || value === null || _Json_isArray(value))
  			{
  				return _Json_expecting('an OBJECT', value);
  			}
  
  			var keyValuePairs = _List_Nil;
  			// TODO test perf of Object.keys and switch when support is good enough
  			for (var key in value)
  			{
  				if (value.hasOwnProperty(key))
  				{
  					var result = _Json_runHelp(decoder.b, value[key]);
  					if (!$elm$core$Result$isOk(result))
  					{
  						return $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));
  					}
  					keyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);
  				}
  			}
  			return $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));
  
  		case 9:
  			var answer = decoder.f;
  			var decoders = decoder.g;
  			for (var i = 0; i < decoders.length; i++)
  			{
  				var result = _Json_runHelp(decoders[i], value);
  				if (!$elm$core$Result$isOk(result))
  				{
  					return result;
  				}
  				answer = answer(result.a);
  			}
  			return $elm$core$Result$Ok(answer);
  
  		case 10:
  			var result = _Json_runHelp(decoder.b, value);
  			return (!$elm$core$Result$isOk(result))
  				? result
  				: _Json_runHelp(decoder.h(result.a), value);
  
  		case 11:
  			var errors = _List_Nil;
  			for (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS
  			{
  				var result = _Json_runHelp(temp.a, value);
  				if ($elm$core$Result$isOk(result))
  				{
  					return result;
  				}
  				errors = _List_Cons(result.a, errors);
  			}
  			return $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));
  
  		case 1:
  			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));
  
  		case 0:
  			return $elm$core$Result$Ok(decoder.a);
  	}
  }
  
  function _Json_runArrayDecoder(decoder, value, toElmValue)
  {
  	var len = value.length;
  	var array = new Array(len);
  	for (var i = 0; i < len; i++)
  	{
  		var result = _Json_runHelp(decoder, value[i]);
  		if (!$elm$core$Result$isOk(result))
  		{
  			return $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));
  		}
  		array[i] = result.a;
  	}
  	return $elm$core$Result$Ok(toElmValue(array));
  }
  
  function _Json_isArray(value)
  {
  	return Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);
  }
  
  function _Json_toElmArray(array)
  {
  	return A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });
  }
  
  function _Json_expecting(type, value)
  {
  	return $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));
  }
  
  
  // EQUALITY
  
  function _Json_equality(x, y)
  {
  	if (x === y)
  	{
  		return true;
  	}
  
  	if (x.$ !== y.$)
  	{
  		return false;
  	}
  
  	switch (x.$)
  	{
  		case 0:
  		case 1:
  			return x.a === y.a;
  
  		case 2:
  			return x.b === y.b;
  
  		case 5:
  			return x.c === y.c;
  
  		case 3:
  		case 4:
  		case 8:
  			return _Json_equality(x.b, y.b);
  
  		case 6:
  			return x.d === y.d && _Json_equality(x.b, y.b);
  
  		case 7:
  			return x.e === y.e && _Json_equality(x.b, y.b);
  
  		case 9:
  			return x.f === y.f && _Json_listEquality(x.g, y.g);
  
  		case 10:
  			return x.h === y.h && _Json_equality(x.b, y.b);
  
  		case 11:
  			return _Json_listEquality(x.g, y.g);
  	}
  }
  
  function _Json_listEquality(aDecoders, bDecoders)
  {
  	var len = aDecoders.length;
  	if (len !== bDecoders.length)
  	{
  		return false;
  	}
  	for (var i = 0; i < len; i++)
  	{
  		if (!_Json_equality(aDecoders[i], bDecoders[i]))
  		{
  			return false;
  		}
  	}
  	return true;
  }
  
  
  // ENCODE
  
  var _Json_encode = F2(function(indentLevel, value)
  {
  	return JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';
  });
  
  function _Json_wrap_UNUSED(value) { return { $: 0, a: value }; }
  function _Json_unwrap_UNUSED(value) { return value.a; }
  
  function _Json_wrap(value) { return value; }
  function _Json_unwrap(value) { return value; }
  
  function _Json_emptyArray() { return []; }
  function _Json_emptyObject() { return {}; }
  
  var _Json_addField = F3(function(key, value, object)
  {
  	object[key] = _Json_unwrap(value);
  	return object;
  });
  
  function _Json_addEntry(func)
  {
  	return F2(function(entry, array)
  	{
  		array.push(_Json_unwrap(func(entry)));
  		return array;
  	});
  }
  
  var _Json_encodeNull = _Json_wrap(null);
  
  
  
  // TASKS
  
  function _Scheduler_succeed(value)
  {
  	return {
  		$: 0,
  		a: value
  	};
  }
  
  function _Scheduler_fail(error)
  {
  	return {
  		$: 1,
  		a: error
  	};
  }
  
  function _Scheduler_binding(callback)
  {
  	return {
  		$: 2,
  		b: callback,
  		c: null
  	};
  }
  
  var _Scheduler_andThen = F2(function(callback, task)
  {
  	return {
  		$: 3,
  		b: callback,
  		d: task
  	};
  });
  
  var _Scheduler_onError = F2(function(callback, task)
  {
  	return {
  		$: 4,
  		b: callback,
  		d: task
  	};
  });
  
  function _Scheduler_receive(callback)
  {
  	return {
  		$: 5,
  		b: callback
  	};
  }
  
  
  // PROCESSES
  
  var _Scheduler_guid = 0;
  
  function _Scheduler_rawSpawn(task)
  {
  	var proc = {
  		$: 0,
  		e: _Scheduler_guid++,
  		f: task,
  		g: null,
  		h: []
  	};
  
  	_Scheduler_enqueue(proc);
  
  	return proc;
  }
  
  function _Scheduler_spawn(task)
  {
  	return _Scheduler_binding(function(callback) {
  		callback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));
  	});
  }
  
  function _Scheduler_rawSend(proc, msg)
  {
  	proc.h.push(msg);
  	_Scheduler_enqueue(proc);
  }
  
  var _Scheduler_send = F2(function(proc, msg)
  {
  	return _Scheduler_binding(function(callback) {
  		_Scheduler_rawSend(proc, msg);
  		callback(_Scheduler_succeed(_Utils_Tuple0));
  	});
  });
  
  function _Scheduler_kill(proc)
  {
  	return _Scheduler_binding(function(callback) {
  		var task = proc.f;
  		if (task.$ === 2 && task.c)
  		{
  			task.c();
  		}
  
  		proc.f = null;
  
  		callback(_Scheduler_succeed(_Utils_Tuple0));
  	});
  }
  
  
  /* STEP PROCESSES
  
  type alias Process =
    { $ : tag
    , id : unique_id
    , root : Task
    , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }
    , mailbox : [msg]
    }
  
  */
  
  
  var _Scheduler_working = false;
  var _Scheduler_queue = [];
  
  
  function _Scheduler_enqueue(proc)
  {
  	_Scheduler_queue.push(proc);
  	if (_Scheduler_working)
  	{
  		return;
  	}
  	_Scheduler_working = true;
  	while (proc = _Scheduler_queue.shift())
  	{
  		_Scheduler_step(proc);
  	}
  	_Scheduler_working = false;
  }
  
  
  function _Scheduler_step(proc)
  {
  	while (proc.f)
  	{
  		var rootTag = proc.f.$;
  		if (rootTag === 0 || rootTag === 1)
  		{
  			while (proc.g && proc.g.$ !== rootTag)
  			{
  				proc.g = proc.g.i;
  			}
  			if (!proc.g)
  			{
  				return;
  			}
  			proc.f = proc.g.b(proc.f.a);
  			proc.g = proc.g.i;
  		}
  		else if (rootTag === 2)
  		{
  			proc.f.c = proc.f.b(function(newRoot) {
  				proc.f = newRoot;
  				_Scheduler_enqueue(proc);
  			});
  			return;
  		}
  		else if (rootTag === 5)
  		{
  			if (proc.h.length === 0)
  			{
  				return;
  			}
  			proc.f = proc.f.b(proc.h.shift());
  		}
  		else // if (rootTag === 3 || rootTag === 4)
  		{
  			proc.g = {
  				$: rootTag === 3 ? 0 : 1,
  				b: proc.f.b,
  				i: proc.g
  			};
  			proc.f = proc.f.d;
  		}
  	}
  }
  
  
  
  function _Process_sleep(time)
  {
  	return _Scheduler_binding(function(callback) {
  		var id = setTimeout(function() {
  			callback(_Scheduler_succeed(_Utils_Tuple0));
  		}, time);
  
  		return function() { clearTimeout(id); };
  	});
  }
  
  
  
  
  // PROGRAMS
  
  
  var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)
  {
  	return _Platform_initialize(
  		flagDecoder,
  		args,
  		impl.dw,
  		impl.et,
  		impl.d8,
  		function() { return function() {} }
  	);
  });
  
  
  
  // INITIALIZE A PROGRAM
  
  
  function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)
  {
  	var result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));
  	$elm$core$Result$isOk(result) || _Debug_crash(2 /**_UNUSED/, _Json_errorToString(result.a) /**/);
  	var managers = {};
  	var initPair = init(result.a);
  	var model = initPair.a;
  	var stepper = stepperBuilder(sendToApp, model);
  	var ports = _Platform_setupEffects(managers, sendToApp);
  
  	function sendToApp(msg, viewMetadata)
  	{
  		var pair = A2(update, msg, model);
  		stepper(model = pair.a, viewMetadata);
  		_Platform_enqueueEffects(managers, pair.b, subscriptions(model));
  	}
  
  	_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));
  
  	return ports ? { ports: ports } : {};
  }
  
  
  
  // TRACK PRELOADS
  //
  // This is used by code in elm/browser and elm/http
  // to register any HTTP requests that are triggered by init.
  //
  
  
  var _Platform_preload;
  
  
  function _Platform_registerPreload(url)
  {
  	_Platform_preload.add(url);
  }
  
  
  
  // EFFECT MANAGERS
  
  
  var _Platform_effectManagers = {};
  
  
  function _Platform_setupEffects(managers, sendToApp)
  {
  	var ports;
  
  	// setup all necessary effect managers
  	for (var key in _Platform_effectManagers)
  	{
  		var manager = _Platform_effectManagers[key];
  
  		if (manager.a)
  		{
  			ports = ports || {};
  			ports[key] = manager.a(key, sendToApp);
  		}
  
  		managers[key] = _Platform_instantiateManager(manager, sendToApp);
  	}
  
  	return ports;
  }
  
  
  function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)
  {
  	return {
  		b: init,
  		c: onEffects,
  		d: onSelfMsg,
  		e: cmdMap,
  		f: subMap
  	};
  }
  
  
  function _Platform_instantiateManager(info, sendToApp)
  {
  	var router = {
  		g: sendToApp,
  		h: undefined
  	};
  
  	var onEffects = info.c;
  	var onSelfMsg = info.d;
  	var cmdMap = info.e;
  	var subMap = info.f;
  
  	function loop(state)
  	{
  		return A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)
  		{
  			var value = msg.a;
  
  			if (msg.$ === 0)
  			{
  				return A3(onSelfMsg, router, value, state);
  			}
  
  			return cmdMap && subMap
  				? A4(onEffects, router, value.i, value.j, state)
  				: A3(onEffects, router, cmdMap ? value.i : value.j, state);
  		}));
  	}
  
  	return router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));
  }
  
  
  
  // ROUTING
  
  
  var _Platform_sendToApp = F2(function(router, msg)
  {
  	return _Scheduler_binding(function(callback)
  	{
  		router.g(msg);
  		callback(_Scheduler_succeed(_Utils_Tuple0));
  	});
  });
  
  
  var _Platform_sendToSelf = F2(function(router, msg)
  {
  	return A2(_Scheduler_send, router.h, {
  		$: 0,
  		a: msg
  	});
  });
  
  
  
  // BAGS
  
  
  function _Platform_leaf(home)
  {
  	return function(value)
  	{
  		return {
  			$: 1,
  			k: home,
  			l: value
  		};
  	};
  }
  
  
  function _Platform_batch(list)
  {
  	return {
  		$: 2,
  		m: list
  	};
  }
  
  
  var _Platform_map = F2(function(tagger, bag)
  {
  	return {
  		$: 3,
  		n: tagger,
  		o: bag
  	}
  });
  
  
  
  // PIPE BAGS INTO EFFECT MANAGERS
  //
  // Effects must be queued!
  //
  // Say your init contains a synchronous command, like Time.now or Time.here
  //
  //   - This will produce a batch of effects (FX_1)
  //   - The synchronous task triggers the subsequent `update` call
  //   - This will produce a batch of effects (FX_2)
  //
  // If we just start dispatching FX_2, subscriptions from FX_2 can be processed
  // before subscriptions from FX_1. No good! Earlier versions of this code had
  // this problem, leading to these reports:
  //
  //   https://github.com/elm/core/issues/980
  //   https://github.com/elm/core/pull/981
  //   https://github.com/elm/compiler/issues/1776
  //
  // The queue is necessary to avoid ordering issues for synchronous commands.
  
  
  // Why use true/false here? Why not just check the length of the queue?
  // The goal is to detect "are we currently dispatching effects?" If we
  // are, we need to bail and let the ongoing while loop handle things.
  //
  // Now say the queue has 1 element. When we dequeue the final element,
  // the queue will be empty, but we are still actively dispatching effects.
  // So you could get queue jumping in a really tricky category of cases.
  //
  var _Platform_effectsQueue = [];
  var _Platform_effectsActive = false;
  
  
  function _Platform_enqueueEffects(managers, cmdBag, subBag)
  {
  	_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });
  
  	if (_Platform_effectsActive) return;
  
  	_Platform_effectsActive = true;
  	for (var fx; fx = _Platform_effectsQueue.shift(); )
  	{
  		_Platform_dispatchEffects(fx.p, fx.q, fx.r);
  	}
  	_Platform_effectsActive = false;
  }
  
  
  function _Platform_dispatchEffects(managers, cmdBag, subBag)
  {
  	var effectsDict = {};
  	_Platform_gatherEffects(true, cmdBag, effectsDict, null);
  	_Platform_gatherEffects(false, subBag, effectsDict, null);
  
  	for (var home in managers)
  	{
  		_Scheduler_rawSend(managers[home], {
  			$: 'fx',
  			a: effectsDict[home] || { i: _List_Nil, j: _List_Nil }
  		});
  	}
  }
  
  
  function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)
  {
  	switch (bag.$)
  	{
  		case 1:
  			var home = bag.k;
  			var effect = _Platform_toEffect(isCmd, home, taggers, bag.l);
  			effectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);
  			return;
  
  		case 2:
  			for (var list = bag.m; list.b; list = list.b) // WHILE_CONS
  			{
  				_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);
  			}
  			return;
  
  		case 3:
  			_Platform_gatherEffects(isCmd, bag.o, effectsDict, {
  				s: bag.n,
  				t: taggers
  			});
  			return;
  	}
  }
  
  
  function _Platform_toEffect(isCmd, home, taggers, value)
  {
  	function applyTaggers(x)
  	{
  		for (var temp = taggers; temp; temp = temp.t)
  		{
  			x = temp.s(x);
  		}
  		return x;
  	}
  
  	var map = isCmd
  		? _Platform_effectManagers[home].e
  		: _Platform_effectManagers[home].f;
  
  	return A2(map, applyTaggers, value)
  }
  
  
  function _Platform_insert(isCmd, newEffect, effects)
  {
  	effects = effects || { i: _List_Nil, j: _List_Nil };
  
  	isCmd
  		? (effects.i = _List_Cons(newEffect, effects.i))
  		: (effects.j = _List_Cons(newEffect, effects.j));
  
  	return effects;
  }
  
  
  
  // PORTS
  
  
  function _Platform_checkPortName(name)
  {
  	if (_Platform_effectManagers[name])
  	{
  		_Debug_crash(3, name)
  	}
  }
  
  
  
  // OUTGOING PORTS
  
  
  function _Platform_outgoingPort(name, converter)
  {
  	_Platform_checkPortName(name);
  	_Platform_effectManagers[name] = {
  		e: _Platform_outgoingPortMap,
  		u: converter,
  		a: _Platform_setupOutgoingPort
  	};
  	return _Platform_leaf(name);
  }
  
  
  var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });
  
  
  function _Platform_setupOutgoingPort(name)
  {
  	var subs = [];
  	var converter = _Platform_effectManagers[name].u;
  
  	// CREATE MANAGER
  
  	var init = _Process_sleep(0);
  
  	_Platform_effectManagers[name].b = init;
  	_Platform_effectManagers[name].c = F3(function(router, cmdList, state)
  	{
  		for ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS
  		{
  			// grab a separate reference to subs in case unsubscribe is called
  			var currentSubs = subs;
  			var value = _Json_unwrap(converter(cmdList.a));
  			for (var i = 0; i < currentSubs.length; i++)
  			{
  				currentSubs[i](value);
  			}
  		}
  		return init;
  	});
  
  	// 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 _Platform_incomingPort(name, converter)
  {
  	_Platform_checkPortName(name);
  	_Platform_effectManagers[name] = {
  		f: _Platform_incomingPortMap,
  		u: converter,
  		a: _Platform_setupIncomingPort
  	};
  	return _Platform_leaf(name);
  }
  
  
  var _Platform_incomingPortMap = F2(function(tagger, finalTagger)
  {
  	return function(value)
  	{
  		return tagger(finalTagger(value));
  	};
  });
  
  
  function _Platform_setupIncomingPort(name, sendToApp)
  {
  	var subs = _List_Nil;
  	var converter = _Platform_effectManagers[name].u;
  
  	// CREATE MANAGER
  
  	var init = _Scheduler_succeed(null);
  
  	_Platform_effectManagers[name].b = init;
  	_Platform_effectManagers[name].c = F3(function(router, subList, state)
  	{
  		subs = subList;
  		return init;
  	});
  
  	// PUBLIC API
  
  	function send(incomingValue)
  	{
  		var result = A2(_Json_run, converter, _Json_wrap(incomingValue));
  
  		$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);
  
  		var value = result.a;
  		for (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS
  		{
  			sendToApp(temp.a(value));
  		}
  	}
  
  	return { send: send };
  }
  
  
  
  // EXPORT ELM MODULES
  //
  // Have DEBUG and PROD versions so that we can (1) give nicer errors in
  // debug mode and (2) not pay for the bits needed for that in prod mode.
  //
  
  
  function _Platform_export(exports)
  {
  	scope['Elm']
  		? _Platform_mergeExportsProd(scope['Elm'], exports)
  		: scope['Elm'] = exports;
  }
  
  
  function _Platform_mergeExportsProd(obj, exports)
  {
  	for (var name in exports)
  	{
  		(name in obj)
  			? (name == 'init')
  				? _Debug_crash(6)
  				: _Platform_mergeExportsProd(obj[name], exports[name])
  			: (obj[name] = exports[name]);
  	}
  }
  
  
  function _Platform_export_UNUSED(exports)
  {
  	scope['Elm']
  		? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)
  		: scope['Elm'] = exports;
  }
  
  
  function _Platform_mergeExportsDebug(moduleName, obj, exports)
  {
  	for (var name in exports)
  	{
  		(name in obj)
  			? (name == 'init')
  				? _Debug_crash(6, moduleName)
  				: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])
  			: (obj[name] = exports[name]);
  	}
  }
  
  
  
  
  // HELPERS
  
  
  var _VirtualDom_divertHrefToApp;
  
  var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};
  
  
  function _VirtualDom_appendChild(parent, child)
  {
  	parent.appendChild(child);
  }
  
  var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)
  {
  	// NOTE: this function needs _Platform_export available to work
  
  	/**/
  	var node = args['node'];
  	//*/
  	/**_UNUSED/
  	var node = args && args['node'] ? args['node'] : _Debug_crash(0);
  	//*/
  
  	node.parentNode.replaceChild(
  		_VirtualDom_render(virtualNode, function() {}),
  		node
  	);
  
  	return {};
  });
  
  
  
  // TEXT
  
  
  function _VirtualDom_text(string)
  {
  	return {
  		$: 0,
  		a: string
  	};
  }
  
  
  
  // NODE
  
  
  var _VirtualDom_nodeNS = F2(function(namespace, tag)
  {
  	return F2(function(factList, kidList)
  	{
  		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
  		{
  			var kid = kidList.a;
  			descendantsCount += (kid.b || 0);
  			kids.push(kid);
  		}
  		descendantsCount += kids.length;
  
  		return {
  			$: 1,
  			c: tag,
  			d: _VirtualDom_organizeFacts(factList),
  			e: kids,
  			f: namespace,
  			b: descendantsCount
  		};
  	});
  });
  
  
  var _VirtualDom_node = _VirtualDom_nodeNS(undefined);
  
  
  
  // KEYED NODE
  
  
  var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)
  {
  	return F2(function(factList, kidList)
  	{
  		for (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS
  		{
  			var kid = kidList.a;
  			descendantsCount += (kid.b.b || 0);
  			kids.push(kid);
  		}
  		descendantsCount += kids.length;
  
  		return {
  			$: 2,
  			c: tag,
  			d: _VirtualDom_organizeFacts(factList),
  			e: kids,
  			f: namespace,
  			b: descendantsCount
  		};
  	});
  });
  
  
  var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);
  
  
  
  // CUSTOM
  
  
  function _VirtualDom_custom(factList, model, render, diff)
  {
  	return {
  		$: 3,
  		d: _VirtualDom_organizeFacts(factList),
  		g: model,
  		h: render,
  		i: diff
  	};
  }
  
  
  
  // MAP
  
  
  var _VirtualDom_map = F2(function(tagger, node)
  {
  	return {
  		$: 4,
  		j: tagger,
  		k: node,
  		b: 1 + (node.b || 0)
  	};
  });
  
  
  
  // LAZY
  
  
  function _VirtualDom_thunk(refs, thunk)
  {
  	return {
  		$: 5,
  		l: refs,
  		m: thunk,
  		k: undefined
  	};
  }
  
  var _VirtualDom_lazy = F2(function(func, a)
  {
  	return _VirtualDom_thunk([func, a], function() {
  		return func(a);
  	});
  });
  
  var _VirtualDom_lazy2 = F3(function(func, a, b)
  {
  	return _VirtualDom_thunk([func, a, b], function() {
  		return A2(func, a, b);
  	});
  });
  
  var _VirtualDom_lazy3 = F4(function(func, a, b, c)
  {
  	return _VirtualDom_thunk([func, a, b, c], function() {
  		return A3(func, a, b, c);
  	});
  });
  
  var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)
  {
  	return _VirtualDom_thunk([func, a, b, c, d], function() {
  		return A4(func, a, b, c, d);
  	});
  });
  
  var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)
  {
  	return _VirtualDom_thunk([func, a, b, c, d, e], function() {
  		return A5(func, a, b, c, d, e);
  	});
  });
  
  var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)
  {
  	return _VirtualDom_thunk([func, a, b, c, d, e, f], function() {
  		return A6(func, a, b, c, d, e, f);
  	});
  });
  
  var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)
  {
  	return _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {
  		return A7(func, a, b, c, d, e, f, g);
  	});
  });
  
  var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)
  {
  	return _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {
  		return A8(func, a, b, c, d, e, f, g, h);
  	});
  });
  
  
  
  // FACTS
  
  
  var _VirtualDom_on = F2(function(key, handler)
  {
  	return {
  		$: 'a0',
  		n: key,
  		o: handler
  	};
  });
  var _VirtualDom_style = F2(function(key, value)
  {
  	return {
  		$: 'a1',
  		n: key,
  		o: value
  	};
  });
  var _VirtualDom_property = F2(function(key, value)
  {
  	return {
  		$: 'a2',
  		n: key,
  		o: value
  	};
  });
  var _VirtualDom_attribute = F2(function(key, value)
  {
  	return {
  		$: 'a3',
  		n: key,
  		o: value
  	};
  });
  var _VirtualDom_attributeNS = F3(function(namespace, key, value)
  {
  	return {
  		$: 'a4',
  		n: key,
  		o: { f: namespace, o: value }
  	};
  });
  
  
  
  // XSS ATTACK VECTOR CHECKS
  
  
  function _VirtualDom_noScript(tag)
  {
  	return tag == 'script' ? 'p' : tag;
  }
  
  function _VirtualDom_noOnOrFormAction(key)
  {
  	return /^(on|formAction$)/i.test(key) ? 'data-' + key : key;
  }
  
  function _VirtualDom_noInnerHtmlOrFormAction(key)
  {
  	return key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;
  }
  
  function _VirtualDom_noJavaScriptUri(value)
  {
  	return /^javascript:/i.test(value.replace(/\s/g,'')) ? '' : value;
  }
  
  function _VirtualDom_noJavaScriptUri_UNUSED(value)
  {
  	return /^javascript:/i.test(value.replace(/\s/g,''))
  		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
  		: value;
  }
  
  function _VirtualDom_noJavaScriptOrHtmlUri(value)
  {
  	return /^\s*(javascript:|data:text\/html)/i.test(value) ? '' : value;
  }
  
  function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)
  {
  	return /^\s*(javascript:|data:text\/html)/i.test(value)
  		? 'javascript:alert("This is an XSS vector. Please use ports or web components instead.")'
  		: value;
  }
  
  
  
  // MAP FACTS
  
  
  var _VirtualDom_mapAttribute = F2(function(func, attr)
  {
  	return (attr.$ === 'a0')
  		? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))
  		: attr;
  });
  
  function _VirtualDom_mapHandler(func, handler)
  {
  	var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
  
  	// 0 = Normal
  	// 1 = MayStopPropagation
  	// 2 = MayPreventDefault
  	// 3 = Custom
  
  	return {
  		$: handler.$,
  		a:
  			!tag
  				? A2($elm$json$Json$Decode$map, func, handler.a)
  				:
  			A3($elm$json$Json$Decode$map2,
  				tag < 3
  					? _VirtualDom_mapEventTuple
  					: _VirtualDom_mapEventRecord,
  				$elm$json$Json$Decode$succeed(func),
  				handler.a
  			)
  	};
  }
  
  var _VirtualDom_mapEventTuple = F2(function(func, tuple)
  {
  	return _Utils_Tuple2(func(tuple.a), tuple.b);
  });
  
  var _VirtualDom_mapEventRecord = F2(function(func, record)
  {
  	return {
  		L: func(record.L),
  		bw: record.bw,
  		bp: record.bp
  	}
  });
  
  
  
  // ORGANIZE FACTS
  
  
  function _VirtualDom_organizeFacts(factList)
  {
  	for (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS
  	{
  		var entry = factList.a;
  
  		var tag = entry.$;
  		var key = entry.n;
  		var value = entry.o;
  
  		if (tag === 'a2')
  		{
  			(key === 'className')
  				? _VirtualDom_addClass(facts, key, _Json_unwrap(value))
  				: facts[key] = _Json_unwrap(value);
  
  			continue;
  		}
  
  		var subFacts = facts[tag] || (facts[tag] = {});
  		(tag === 'a3' && key === 'class')
  			? _VirtualDom_addClass(subFacts, key, value)
  			: subFacts[key] = value;
  	}
  
  	return facts;
  }
  
  function _VirtualDom_addClass(object, key, newClass)
  {
  	var classes = object[key];
  	object[key] = classes ? classes + ' ' + newClass : newClass;
  }
  
  
  
  // RENDER
  
  
  function _VirtualDom_render(vNode, eventNode)
  {
  	var tag = vNode.$;
  
  	if (tag === 5)
  	{
  		return _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);
  	}
  
  	if (tag === 0)
  	{
  		return _VirtualDom_doc.createTextNode(vNode.a);
  	}
  
  	if (tag === 4)
  	{
  		var subNode = vNode.k;
  		var tagger = vNode.j;
  
  		while (subNode.$ === 4)
  		{
  			typeof tagger !== 'object'
  				? tagger = [tagger, subNode.j]
  				: tagger.push(subNode.j);
  
  			subNode = subNode.k;
  		}
  
  		var subEventRoot = { j: tagger, p: eventNode };
  		var domNode = _VirtualDom_render(subNode, subEventRoot);
  		domNode.elm_event_node_ref = subEventRoot;
  		return domNode;
  	}
  
  	if (tag === 3)
  	{
  		var domNode = vNode.h(vNode.g);
  		_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
  		return domNode;
  	}
  
  	// at this point `tag` must be 1 or 2
  
  	var domNode = vNode.f
  		? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)
  		: _VirtualDom_doc.createElement(vNode.c);
  
  	if (_VirtualDom_divertHrefToApp && vNode.c == 'a')
  	{
  		domNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));
  	}
  
  	_VirtualDom_applyFacts(domNode, eventNode, vNode.d);
  
  	for (var kids = vNode.e, i = 0; i < kids.length; i++)
  	{
  		_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));
  	}
  
  	return domNode;
  }
  
  
  
  // APPLY FACTS
  
  
  function _VirtualDom_applyFacts(domNode, eventNode, facts)
  {
  	for (var key in facts)
  	{
  		var value = facts[key];
  
  		key === 'a1'
  			? _VirtualDom_applyStyles(domNode, value)
  			:
  		key === 'a0'
  			? _VirtualDom_applyEvents(domNode, eventNode, value)
  			:
  		key === 'a3'
  			? _VirtualDom_applyAttrs(domNode, value)
  			:
  		key === 'a4'
  			? _VirtualDom_applyAttrsNS(domNode, value)
  			:
  		((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);
  	}
  }
  
  
  
  // APPLY STYLES
  
  
  function _VirtualDom_applyStyles(domNode, styles)
  {
  	var domNodeStyle = domNode.style;
  
  	for (var key in styles)
  	{
  		domNodeStyle[key] = styles[key];
  	}
  }
  
  
  
  // APPLY ATTRS
  
  
  function _VirtualDom_applyAttrs(domNode, attrs)
  {
  	for (var key in attrs)
  	{
  		var value = attrs[key];
  		typeof value !== 'undefined'
  			? domNode.setAttribute(key, value)
  			: domNode.removeAttribute(key);
  	}
  }
  
  
  
  // APPLY NAMESPACED ATTRS
  
  
  function _VirtualDom_applyAttrsNS(domNode, nsAttrs)
  {
  	for (var key in nsAttrs)
  	{
  		var pair = nsAttrs[key];
  		var namespace = pair.f;
  		var value = pair.o;
  
  		typeof value !== 'undefined'
  			? domNode.setAttributeNS(namespace, key, value)
  			: domNode.removeAttributeNS(namespace, key);
  	}
  }
  
  
  
  // APPLY EVENTS
  
  
  function _VirtualDom_applyEvents(domNode, eventNode, events)
  {
  	var allCallbacks = domNode.elmFs || (domNode.elmFs = {});
  
  	for (var key in events)
  	{
  		var newHandler = events[key];
  		var oldCallback = allCallbacks[key];
  
  		if (!newHandler)
  		{
  			domNode.removeEventListener(key, oldCallback);
  			allCallbacks[key] = undefined;
  			continue;
  		}
  
  		if (oldCallback)
  		{
  			var oldHandler = oldCallback.q;
  			if (oldHandler.$ === newHandler.$)
  			{
  				oldCallback.q = newHandler;
  				continue;
  			}
  			domNode.removeEventListener(key, oldCallback);
  		}
  
  		oldCallback = _VirtualDom_makeCallback(eventNode, newHandler);
  		domNode.addEventListener(key, oldCallback,
  			_VirtualDom_passiveSupported
  			&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }
  		);
  		allCallbacks[key] = oldCallback;
  	}
  }
  
  
  
  // PASSIVE EVENTS
  
  
  var _VirtualDom_passiveSupported;
  
  try
  {
  	window.addEventListener('t', null, Object.defineProperty({}, 'passive', {
  		get: function() { _VirtualDom_passiveSupported = true; }
  	}));
  }
  catch(e) {}
  
  
  
  // EVENT HANDLERS
  
  
  function _VirtualDom_makeCallback(eventNode, initialHandler)
  {
  	function callback(event)
  	{
  		var handler = callback.q;
  		var result = _Json_runHelp(handler.a, event);
  
  		if (!$elm$core$Result$isOk(result))
  		{
  			return;
  		}
  
  		var tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);
  
  		// 0 = Normal
  		// 1 = MayStopPropagation
  		// 2 = MayPreventDefault
  		// 3 = Custom
  
  		var value = result.a;
  		var message = !tag ? value : tag < 3 ? value.a : value.L;
  		var stopPropagation = tag == 1 ? value.b : tag == 3 && value.bw;
  		var currentEventNode = (
  			stopPropagation && event.stopPropagation(),
  			(tag == 2 ? value.b : tag == 3 && value.bp) && event.preventDefault(),
  			eventNode
  		);
  		var tagger;
  		var i;
  		while (tagger = currentEventNode.j)
  		{
  			if (typeof tagger == 'function')
  			{
  				message = tagger(message);
  			}
  			else
  			{
  				for (var i = tagger.length; i--; )
  				{
  					message = tagger[i](message);
  				}
  			}
  			currentEventNode = currentEventNode.p;
  		}
  		currentEventNode(message, stopPropagation); // stopPropagation implies isSync
  	}
  
  	callback.q = initialHandler;
  
  	return callback;
  }
  
  function _VirtualDom_equalEvents(x, y)
  {
  	return x.$ == y.$ && _Json_equality(x.a, y.a);
  }
  
  
  
  // DIFF
  
  
  // TODO: Should we do patches like in iOS?
  //
  // type Patch
  //   = At Int Patch
  //   | Batch (List Patch)
  //   | Change ...
  //
  // How could it not be better?
  //
  function _VirtualDom_diff(x, y)
  {
  	var patches = [];
  	_VirtualDom_diffHelp(x, y, patches, 0);
  	return patches;
  }
  
  
  function _VirtualDom_pushPatch(patches, type, index, data)
  {
  	var patch = {
  		$: type,
  		r: index,
  		s: data,
  		t: undefined,
  		u: undefined
  	};
  	patches.push(patch);
  	return patch;
  }
  
  
  function _VirtualDom_diffHelp(x, y, patches, index)
  {
  	if (x === y)
  	{
  		return;
  	}
  
  	var xType = x.$;
  	var yType = y.$;
  
  	// Bail if you run into different types of nodes. Implies that the
  	// structure has changed significantly and it's not worth a diff.
  	if (xType !== yType)
  	{
  		if (xType === 1 && yType === 2)
  		{
  			y = _VirtualDom_dekey(y);
  			yType = 1;
  		}
  		else
  		{
  			_VirtualDom_pushPatch(patches, 0, index, y);
  			return;
  		}
  	}
  
  	// Now we know that both nodes are the same $.
  	switch (yType)
  	{
  		case 5:
  			var xRefs = x.l;
  			var yRefs = y.l;
  			var i = xRefs.length;
  			var same = i === yRefs.length;
  			while (same && i--)
  			{
  				same = xRefs[i] === yRefs[i];
  			}
  			if (same)
  			{
  				y.k = x.k;
  				return;
  			}
  			y.k = y.m();
  			var subPatches = [];
  			_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);
  			subPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);
  			return;
  
  		case 4:
  			// gather nested taggers
  			var xTaggers = x.j;
  			var yTaggers = y.j;
  			var nesting = false;
  
  			var xSubNode = x.k;
  			while (xSubNode.$ === 4)
  			{
  				nesting = true;
  
  				typeof xTaggers !== 'object'
  					? xTaggers = [xTaggers, xSubNode.j]
  					: xTaggers.push(xSubNode.j);
  
  				xSubNode = xSubNode.k;
  			}
  
  			var ySubNode = y.k;
  			while (ySubNode.$ === 4)
  			{
  				nesting = true;
  
  				typeof yTaggers !== 'object'
  					? yTaggers = [yTaggers, ySubNode.j]
  					: yTaggers.push(ySubNode.j);
  
  				ySubNode = ySubNode.k;
  			}
  
  			// Just bail if different numbers of taggers. This implies the
  			// structure of the virtual DOM has changed.
  			if (nesting && xTaggers.length !== yTaggers.length)
  			{
  				_VirtualDom_pushPatch(patches, 0, index, y);
  				return;
  			}
  
  			// check if taggers are "the same"
  			if (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)
  			{
  				_VirtualDom_pushPatch(patches, 2, index, yTaggers);
  			}
  
  			// diff everything below the taggers
  			_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);
  			return;
  
  		case 0:
  			if (x.a !== y.a)
  			{
  				_VirtualDom_pushPatch(patches, 3, index, y.a);
  			}
  			return;
  
  		case 1:
  			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);
  			return;
  
  		case 2:
  			_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);
  			return;
  
  		case 3:
  			if (x.h !== y.h)
  			{
  				_VirtualDom_pushPatch(patches, 0, index, y);
  				return;
  			}
  
  			var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
  			factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
  
  			var patch = y.i(x.g, y.g);
  			patch && _VirtualDom_pushPatch(patches, 5, index, patch);
  
  			return;
  	}
  }
  
  // assumes the incoming arrays are the same length
  function _VirtualDom_pairwiseRefEqual(as, bs)
  {
  	for (var i = 0; i < as.length; i++)
  	{
  		if (as[i] !== bs[i])
  		{
  			return false;
  		}
  	}
  
  	return true;
  }
  
  function _VirtualDom_diffNodes(x, y, patches, index, diffKids)
  {
  	// Bail if obvious indicators have changed. Implies more serious
  	// structural changes such that it's not worth it to diff.
  	if (x.c !== y.c || x.f !== y.f)
  	{
  		_VirtualDom_pushPatch(patches, 0, index, y);
  		return;
  	}
  
  	var factsDiff = _VirtualDom_diffFacts(x.d, y.d);
  	factsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);
  
  	diffKids(x, y, patches, index);
  }
  
  
  
  // DIFF FACTS
  
  
  // 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 _VirtualDom_diffFacts(x, y, category)
  {
  	var diff;
  
  	// look for changes and removals
  	for (var xKey in x)
  	{
  		if (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')
  		{
  			var subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);
  			if (subDiff)
  			{
  				diff = diff || {};
  				diff[xKey] = subDiff;
  			}
  			continue;
  		}
  
  		// remove if not in the new facts
  		if (!(xKey in y))
  		{
  			diff = diff || {};
  			diff[xKey] =
  				!category
  					? (typeof x[xKey] === 'string' ? '' : null)
  					:
  				(category === 'a1')
  					? ''
  					:
  				(category === 'a0' || category === 'a3')
  					? undefined
  					:
  				{ f: x[xKey].f, o: undefined };
  
  			continue;
  		}
  
  		var xValue = x[xKey];
  		var yValue = y[xKey];
  
  		// reference equal, so don't worry about it
  		if (xValue === yValue && xKey !== 'value' && xKey !== 'checked'
  			|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))
  		{
  			continue;
  		}
  
  		diff = diff || {};
  		diff[xKey] = yValue;
  	}
  
  	// add new stuff
  	for (var yKey in y)
  	{
  		if (!(yKey in x))
  		{
  			diff = diff || {};
  			diff[yKey] = y[yKey];
  		}
  	}
  
  	return diff;
  }
  
  
  
  // DIFF KIDS
  
  
  function _VirtualDom_diffKids(xParent, yParent, patches, index)
  {
  	var xKids = xParent.e;
  	var yKids = yParent.e;
  
  	var xLen = xKids.length;
  	var yLen = yKids.length;
  
  	// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS
  
  	if (xLen > yLen)
  	{
  		_VirtualDom_pushPatch(patches, 6, index, {
  			v: yLen,
  			i: xLen - yLen
  		});
  	}
  	else if (xLen < yLen)
  	{
  		_VirtualDom_pushPatch(patches, 7, index, {
  			v: xLen,
  			e: yKids
  		});
  	}
  
  	// PAIRWISE DIFF EVERYTHING ELSE
  
  	for (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)
  	{
  		var xKid = xKids[i];
  		_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);
  		index += xKid.b || 0;
  	}
  }
  
  
  
  // KEYED DIFF
  
  
  function _VirtualDom_diffKeyedKids(xParent, yParent, 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 xKids = xParent.e;
  	var yKids = yParent.e;
  	var xLen = xKids.length;
  	var yLen = yKids.length;
  	var xIndex = 0;
  	var yIndex = 0;
  
  	var index = rootIndex;
  
  	while (xIndex < xLen && yIndex < yLen)
  	{
  		var x = xKids[xIndex];
  		var y = yKids[yIndex];
  
  		var xKey = x.a;
  		var yKey = y.a;
  		var xNode = x.b;
  		var yNode = y.b;
  
  		var newMatch = undefined;
  		var oldMatch = undefined;
  
  		// check if keys match
  
  		if (xKey === yKey)
  		{
  			index++;
  			_VirtualDom_diffHelp(xNode, yNode, localPatches, index);
  			index += xNode.b || 0;
  
  			xIndex++;
  			yIndex++;
  			continue;
  		}
  
  		// look ahead 1 to detect insertions and removals.
  
  		var xNext = xKids[xIndex + 1];
  		var yNext = yKids[yIndex + 1];
  
  		if (xNext)
  		{
  			var xNextKey = xNext.a;
  			var xNextNode = xNext.b;
  			oldMatch = yKey === xNextKey;
  		}
  
  		if (yNext)
  		{
  			var yNextKey = yNext.a;
  			var yNextNode = yNext.b;
  			newMatch = xKey === yNextKey;
  		}
  
  
  		// swap x and y
  		if (newMatch && oldMatch)
  		{
  			index++;
  			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
  			_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);
  			index += xNode.b || 0;
  
  			index++;
  			_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);
  			index += xNextNode.b || 0;
  
  			xIndex += 2;
  			yIndex += 2;
  			continue;
  		}
  
  		// insert y
  		if (newMatch)
  		{
  			index++;
  			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
  			_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);
  			index += xNode.b || 0;
  
  			xIndex += 1;
  			yIndex += 2;
  			continue;
  		}
  
  		// remove x
  		if (oldMatch)
  		{
  			index++;
  			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
  			index += xNode.b || 0;
  
  			index++;
  			_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);
  			index += xNextNode.b || 0;
  
  			xIndex += 2;
  			yIndex += 1;
  			continue;
  		}
  
  		// remove x, insert y
  		if (xNext && xNextKey === yNextKey)
  		{
  			index++;
  			_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);
  			_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);
  			index += xNode.b || 0;
  
  			index++;
  			_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);
  			index += xNextNode.b || 0;
  
  			xIndex += 2;
  			yIndex += 2;
  			continue;
  		}
  
  		break;
  	}
  
  	// eat up any remaining nodes with removeNode and insertNode
  
  	while (xIndex < xLen)
  	{
  		index++;
  		var x = xKids[xIndex];
  		var xNode = x.b;
  		_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);
  		index += xNode.b || 0;
  		xIndex++;
  	}
  
  	while (yIndex < yLen)
  	{
  		var endInserts = endInserts || [];
  		var y = yKids[yIndex];
  		_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);
  		yIndex++;
  	}
  
  	if (localPatches.length > 0 || inserts.length > 0 || endInserts)
  	{
  		_VirtualDom_pushPatch(patches, 8, rootIndex, {
  			w: localPatches,
  			x: inserts,
  			y: endInserts
  		});
  	}
  }
  
  
  
  // CHANGES FROM KEYED DIFF
  
  
  var _VirtualDom_POSTFIX = '_elmW6BL';
  
  
  function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)
  {
  	var entry = changes[key];
  
  	// never seen this key before
  	if (!entry)
  	{
  		entry = {
  			c: 0,
  			z: vnode,
  			r: yIndex,
  			s: undefined
  		};
  
  		inserts.push({ r: yIndex, A: entry });
  		changes[key] = entry;
  
  		return;
  	}
  
  	// this key was removed earlier, a match!
  	if (entry.c === 1)
  	{
  		inserts.push({ r: yIndex, A: entry });
  
  		entry.c = 2;
  		var subPatches = [];
  		_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);
  		entry.r = yIndex;
  		entry.s.s = {
  			w: subPatches,
  			A: entry
  		};
  
  		return;
  	}
  
  	// this key has already been inserted or moved, a duplicate!
  	_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);
  }
  
  
  function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)
  {
  	var entry = changes[key];
  
  	// never seen this key before
  	if (!entry)
  	{
  		var patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);
  
  		changes[key] = {
  			c: 1,
  			z: vnode,
  			r: index,
  			s: patch
  		};
  
  		return;
  	}
  
  	// this key was inserted earlier, a match!
  	if (entry.c === 0)
  	{
  		entry.c = 2;
  		var subPatches = [];
  		_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);
  
  		_VirtualDom_pushPatch(localPatches, 9, index, {
  			w: subPatches,
  			A: entry
  		});
  
  		return;
  	}
  
  	// this key has already been removed or moved, a duplicate!
  	_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_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 _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)
  {
  	_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);
  }
  
  
  // assumes `patches` is non-empty and indexes increase monotonically.
  function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)
  {
  	var patch = patches[i];
  	var index = patch.r;
  
  	while (index === low)
  	{
  		var patchType = patch.$;
  
  		if (patchType === 1)
  		{
  			_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);
  		}
  		else if (patchType === 8)
  		{
  			patch.t = domNode;
  			patch.u = eventNode;
  
  			var subPatches = patch.s.w;
  			if (subPatches.length > 0)
  			{
  				_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
  			}
  		}
  		else if (patchType === 9)
  		{
  			patch.t = domNode;
  			patch.u = eventNode;
  
  			var data = patch.s;
  			if (data)
  			{
  				data.A.s = domNode;
  				var subPatches = data.w;
  				if (subPatches.length > 0)
  				{
  					_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);
  				}
  			}
  		}
  		else
  		{
  			patch.t = domNode;
  			patch.u = eventNode;
  		}
  
  		i++;
  
  		if (!(patch = patches[i]) || (index = patch.r) > high)
  		{
  			return i;
  		}
  	}
  
  	var tag = vNode.$;
  
  	if (tag === 4)
  	{
  		var subNode = vNode.k;
  
  		while (subNode.$ === 4)
  		{
  			subNode = subNode.k;
  		}
  
  		return _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);
  	}
  
  	// tag must be 1 or 2 at this point
  
  	var vKids = vNode.e;
  	var childNodes = domNode.childNodes;
  	for (var j = 0; j < vKids.length; j++)
  	{
  		low++;
  		var vKid = tag === 1 ? vKids[j] : vKids[j].b;
  		var nextLow = low + (vKid.b || 0);
  		if (low <= index && index <= nextLow)
  		{
  			i = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);
  			if (!(patch = patches[i]) || (index = patch.r) > high)
  			{
  				return i;
  			}
  		}
  		low = nextLow;
  	}
  	return i;
  }
  
  
  
  // APPLY PATCHES
  
  
  function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)
  {
  	if (patches.length === 0)
  	{
  		return rootDomNode;
  	}
  
  	_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);
  	return _VirtualDom_applyPatchesHelp(rootDomNode, patches);
  }
  
  function _VirtualDom_applyPatchesHelp(rootDomNode, patches)
  {
  	for (var i = 0; i < patches.length; i++)
  	{
  		var patch = patches[i];
  		var localDomNode = patch.t
  		var newNode = _VirtualDom_applyPatch(localDomNode, patch);
  		if (localDomNode === rootDomNode)
  		{
  			rootDomNode = newNode;
  		}
  	}
  	return rootDomNode;
  }
  
  function _VirtualDom_applyPatch(domNode, patch)
  {
  	switch (patch.$)
  	{
  		case 0:
  			return _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);
  
  		case 4:
  			_VirtualDom_applyFacts(domNode, patch.u, patch.s);
  			return domNode;
  
  		case 3:
  			domNode.replaceData(0, domNode.length, patch.s);
  			return domNode;
  
  		case 1:
  			return _VirtualDom_applyPatchesHelp(domNode, patch.s);
  
  		case 2:
  			if (domNode.elm_event_node_ref)
  			{
  				domNode.elm_event_node_ref.j = patch.s;
  			}
  			else
  			{
  				domNode.elm_event_node_ref = { j: patch.s, p: patch.u };
  			}
  			return domNode;
  
  		case 6:
  			var data = patch.s;
  			for (var i = 0; i < data.i; i++)
  			{
  				domNode.removeChild(domNode.childNodes[data.v]);
  			}
  			return domNode;
  
  		case 7:
  			var data = patch.s;
  			var kids = data.e;
  			var i = data.v;
  			var theEnd = domNode.childNodes[i];
  			for (; i < kids.length; i++)
  			{
  				domNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);
  			}
  			return domNode;
  
  		case 9:
  			var data = patch.s;
  			if (!data)
  			{
  				domNode.parentNode.removeChild(domNode);
  				return domNode;
  			}
  			var entry = data.A;
  			if (typeof entry.r !== 'undefined')
  			{
  				domNode.parentNode.removeChild(domNode);
  			}
  			entry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);
  			return domNode;
  
  		case 8:
  			return _VirtualDom_applyPatchReorder(domNode, patch);
  
  		case 5:
  			return patch.s(domNode);
  
  		default:
  			_Debug_crash(10); // 'Ran into an unknown patch!'
  	}
  }
  
  
  function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)
  {
  	var parentNode = domNode.parentNode;
  	var newNode = _VirtualDom_render(vNode, eventNode);
  
  	if (!newNode.elm_event_node_ref)
  	{
  		newNode.elm_event_node_ref = domNode.elm_event_node_ref;
  	}
  
  	if (parentNode && newNode !== domNode)
  	{
  		parentNode.replaceChild(newNode, domNode);
  	}
  	return newNode;
  }
  
  
  function _VirtualDom_applyPatchReorder(domNode, patch)
  {
  	var data = patch.s;
  
  	// remove end inserts
  	var frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);
  
  	// removals
  	domNode = _VirtualDom_applyPatchesHelp(domNode, data.w);
  
  	// inserts
  	var inserts = data.x;
  	for (var i = 0; i < inserts.length; i++)
  	{
  		var insert = inserts[i];
  		var entry = insert.A;
  		var node = entry.c === 2
  			? entry.s
  			: _VirtualDom_render(entry.z, patch.u);
  		domNode.insertBefore(node, domNode.childNodes[insert.r]);
  	}
  
  	// add end inserts
  	if (frag)
  	{
  		_VirtualDom_appendChild(domNode, frag);
  	}
  
  	return domNode;
  }
  
  
  function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)
  {
  	if (!endInserts)
  	{
  		return;
  	}
  
  	var frag = _VirtualDom_doc.createDocumentFragment();
  	for (var i = 0; i < endInserts.length; i++)
  	{
  		var insert = endInserts[i];
  		var entry = insert.A;
  		_VirtualDom_appendChild(frag, entry.c === 2
  			? entry.s
  			: _VirtualDom_render(entry.z, patch.u)
  		);
  	}
  	return frag;
  }
  
  
  function _VirtualDom_virtualize(node)
  {
  	// TEXT NODES
  
  	if (node.nodeType === 3)
  	{
  		return _VirtualDom_text(node.textContent);
  	}
  
  
  	// WEIRD NODES
  
  	if (node.nodeType !== 1)
  	{
  		return _VirtualDom_text('');
  	}
  
  
  	// ELEMENT NODES
  
  	var attrList = _List_Nil;
  	var attrs = node.attributes;
  	for (var i = attrs.length; i--; )
  	{
  		var attr = attrs[i];
  		var name = attr.name;
  		var value = attr.value;
  		attrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );
  	}
  
  	var tag = node.tagName.toLowerCase();
  	var kidList = _List_Nil;
  	var kids = node.childNodes;
  
  	for (var i = kids.length; i--; )
  	{
  		kidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);
  	}
  	return A3(_VirtualDom_node, tag, attrList, kidList);
  }
  
  function _VirtualDom_dekey(keyedNode)
  {
  	var keyedKids = keyedNode.e;
  	var len = keyedKids.length;
  	var kids = new Array(len);
  	for (var i = 0; i < len; i++)
  	{
  		kids[i] = keyedKids[i].b;
  	}
  
  	return {
  		$: 1,
  		c: keyedNode.c,
  		d: keyedNode.d,
  		e: kids,
  		f: keyedNode.f,
  		b: keyedNode.b
  	};
  }
  
  
  
  
  // ELEMENT
  
  
  var _Debugger_element;
  
  var _Browser_element = _Debugger_element || F4(function(impl, flagDecoder, debugMetadata, args)
  {
  	return _Platform_initialize(
  		flagDecoder,
  		args,
  		impl.dw,
  		impl.et,
  		impl.d8,
  		function(sendToApp, initialModel) {
  			var view = impl.aq;
  			/**/
  			var domNode = args['node'];
  			//*/
  			/**_UNUSED/
  			var domNode = args && args['node'] ? args['node'] : _Debug_crash(0);
  			//*/
  			var currNode = _VirtualDom_virtualize(domNode);
  
  			return _Browser_makeAnimator(initialModel, function(model)
  			{
  				var nextNode = view(model);
  				var patches = _VirtualDom_diff(currNode, nextNode);
  				domNode = _VirtualDom_applyPatches(domNode, currNode, patches, sendToApp);
  				currNode = nextNode;
  			});
  		}
  	);
  });
  
  
  
  // DOCUMENT
  
  
  var _Debugger_document;
  
  var _Browser_document = _Debugger_document || F4(function(impl, flagDecoder, debugMetadata, args)
  {
  	return _Platform_initialize(
  		flagDecoder,
  		args,
  		impl.dw,
  		impl.et,
  		impl.d8,
  		function(sendToApp, initialModel) {
  			var divertHrefToApp = impl.bu && impl.bu(sendToApp)
  			var view = impl.aq;
  			var title = _VirtualDom_doc.title;
  			var bodyNode = _VirtualDom_doc.body;
  			var currNode = _VirtualDom_virtualize(bodyNode);
  			return _Browser_makeAnimator(initialModel, function(model)
  			{
  				_VirtualDom_divertHrefToApp = divertHrefToApp;
  				var doc = view(model);
  				var nextNode = _VirtualDom_node('body')(_List_Nil)(doc.cW);
  				var patches = _VirtualDom_diff(currNode, nextNode);
  				bodyNode = _VirtualDom_applyPatches(bodyNode, currNode, patches, sendToApp);
  				currNode = nextNode;
  				_VirtualDom_divertHrefToApp = 0;
  				(title !== doc.en) && (_VirtualDom_doc.title = title = doc.en);
  			});
  		}
  	);
  });
  
  
  
  // ANIMATION
  
  
  var _Browser_cancelAnimationFrame =
  	typeof cancelAnimationFrame !== 'undefined'
  		? cancelAnimationFrame
  		: function(id) { clearTimeout(id); };
  
  var _Browser_requestAnimationFrame =
  	typeof requestAnimationFrame !== 'undefined'
  		? requestAnimationFrame
  		: function(callback) { return setTimeout(callback, 1000 / 60); };
  
  
  function _Browser_makeAnimator(model, draw)
  {
  	draw(model);
  
  	var state = 0;
  
  	function updateIfNeeded()
  	{
  		state = state === 1
  			? 0
  			: ( _Browser_requestAnimationFrame(updateIfNeeded), draw(model), 1 );
  	}
  
  	return function(nextModel, isSync)
  	{
  		model = nextModel;
  
  		isSync
  			? ( draw(model),
  				state === 2 && (state = 1)
  				)
  			: ( state === 0 && _Browser_requestAnimationFrame(updateIfNeeded),
  				state = 2
  				);
  	};
  }
  
  
  
  // APPLICATION
  
  
  function _Browser_application(impl)
  {
  	var onUrlChange = impl.dN;
  	var onUrlRequest = impl.dO;
  	var key = function() { key.a(onUrlChange(_Browser_getUrl())); };
  
  	return _Browser_document({
  		bu: function(sendToApp)
  		{
  			key.a = sendToApp;
  			_Browser_window.addEventListener('popstate', key);
  			_Browser_window.navigator.userAgent.indexOf('Trident') < 0 || _Browser_window.addEventListener('hashchange', key);
  
  			return F2(function(domNode, event)
  			{
  				if (!event.ctrlKey && !event.metaKey && !event.shiftKey && event.button < 1 && !domNode.target && !domNode.hasAttribute('download'))
  				{
  					event.preventDefault();
  					var href = domNode.href;
  					var curr = _Browser_getUrl();
  					var next = $elm$url$Url$fromString(href).a;
  					sendToApp(onUrlRequest(
  						(next
  							&& curr.ci === next.ci
  							&& curr.bW === next.bW
  							&& curr.cf.a === next.cf.a
  						)
  							? $elm$browser$Browser$Internal(next)
  							: $elm$browser$Browser$External(href)
  					));
  				}
  			});
  		},
  		dw: function(flags)
  		{
  			return A3(impl.dw, flags, _Browser_getUrl(), key);
  		},
  		aq: impl.aq,
  		et: impl.et,
  		d8: impl.d8
  	});
  }
  
  function _Browser_getUrl()
  {
  	return $elm$url$Url$fromString(_VirtualDom_doc.location.href).a || _Debug_crash(1);
  }
  
  var _Browser_go = F2(function(key, n)
  {
  	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
  		n && history.go(n);
  		key();
  	}));
  });
  
  var _Browser_pushUrl = F2(function(key, url)
  {
  	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
  		history.pushState({}, '', url);
  		key();
  	}));
  });
  
  var _Browser_replaceUrl = F2(function(key, url)
  {
  	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function() {
  		history.replaceState({}, '', url);
  		key();
  	}));
  });
  
  
  
  // GLOBAL EVENTS
  
  
  var _Browser_fakeNode = { addEventListener: function() {}, removeEventListener: function() {} };
  var _Browser_doc = typeof document !== 'undefined' ? document : _Browser_fakeNode;
  var _Browser_window = typeof window !== 'undefined' ? window : _Browser_fakeNode;
  
  var _Browser_on = F3(function(node, eventName, sendToSelf)
  {
  	return _Scheduler_spawn(_Scheduler_binding(function(callback)
  	{
  		function handler(event)	{ _Scheduler_rawSpawn(sendToSelf(event)); }
  		node.addEventListener(eventName, handler, _VirtualDom_passiveSupported && { passive: true });
  		return function() { node.removeEventListener(eventName, handler); };
  	}));
  });
  
  var _Browser_decodeEvent = F2(function(decoder, event)
  {
  	var result = _Json_runHelp(decoder, event);
  	return $elm$core$Result$isOk(result) ? $elm$core$Maybe$Just(result.a) : $elm$core$Maybe$Nothing;
  });
  
  
  
  // PAGE VISIBILITY
  
  
  function _Browser_visibilityInfo()
  {
  	return (typeof _VirtualDom_doc.hidden !== 'undefined')
  		? { dq: 'hidden', c4: 'visibilitychange' }
  		:
  	(typeof _VirtualDom_doc.mozHidden !== 'undefined')
  		? { dq: 'mozHidden', c4: 'mozvisibilitychange' }
  		:
  	(typeof _VirtualDom_doc.msHidden !== 'undefined')
  		? { dq: 'msHidden', c4: 'msvisibilitychange' }
  		:
  	(typeof _VirtualDom_doc.webkitHidden !== 'undefined')
  		? { dq: 'webkitHidden', c4: 'webkitvisibilitychange' }
  		: { dq: 'hidden', c4: 'visibilitychange' };
  }
  
  
  
  // ANIMATION FRAMES
  
  
  function _Browser_rAF()
  {
  	return _Scheduler_binding(function(callback)
  	{
  		var id = _Browser_requestAnimationFrame(function() {
  			callback(_Scheduler_succeed(Date.now()));
  		});
  
  		return function() {
  			_Browser_cancelAnimationFrame(id);
  		};
  	});
  }
  
  
  function _Browser_now()
  {
  	return _Scheduler_binding(function(callback)
  	{
  		callback(_Scheduler_succeed(Date.now()));
  	});
  }
  
  
  
  // DOM STUFF
  
  
  function _Browser_withNode(id, doStuff)
  {
  	return _Scheduler_binding(function(callback)
  	{
  		_Browser_requestAnimationFrame(function() {
  			var node = document.getElementById(id);
  			callback(node
  				? _Scheduler_succeed(doStuff(node))
  				: _Scheduler_fail($elm$browser$Browser$Dom$NotFound(id))
  			);
  		});
  	});
  }
  
  
  function _Browser_withWindow(doStuff)
  {
  	return _Scheduler_binding(function(callback)
  	{
  		_Browser_requestAnimationFrame(function() {
  			callback(_Scheduler_succeed(doStuff()));
  		});
  	});
  }
  
  
  // FOCUS and BLUR
  
  
  var _Browser_call = F2(function(functionName, id)
  {
  	return _Browser_withNode(id, function(node) {
  		node[functionName]();
  		return _Utils_Tuple0;
  	});
  });
  
  
  
  // WINDOW VIEWPORT
  
  
  function _Browser_getViewport()
  {
  	return {
  		cm: _Browser_getScene(),
  		cy: {
  			cB: _Browser_window.pageXOffset,
  			cC: _Browser_window.pageYOffset,
  			aJ: _Browser_doc.documentElement.clientWidth,
  			bS: _Browser_doc.documentElement.clientHeight
  		}
  	};
  }
  
  function _Browser_getScene()
  {
  	var body = _Browser_doc.body;
  	var elem = _Browser_doc.documentElement;
  	return {
  		aJ: Math.max(body.scrollWidth, body.offsetWidth, elem.scrollWidth, elem.offsetWidth, elem.clientWidth),
  		bS: Math.max(body.scrollHeight, body.offsetHeight, elem.scrollHeight, elem.offsetHeight, elem.clientHeight)
  	};
  }
  
  var _Browser_setViewport = F2(function(x, y)
  {
  	return _Browser_withWindow(function()
  	{
  		_Browser_window.scroll(x, y);
  		return _Utils_Tuple0;
  	});
  });
  
  
  
  // ELEMENT VIEWPORT
  
  
  function _Browser_getViewportOf(id)
  {
  	return _Browser_withNode(id, function(node)
  	{
  		return {
  			cm: {
  				aJ: node.scrollWidth,
  				bS: node.scrollHeight
  			},
  			cy: {
  				cB: node.scrollLeft,
  				cC: node.scrollTop,
  				aJ: node.clientWidth,
  				bS: node.clientHeight
  			}
  		};
  	});
  }
  
  
  var _Browser_setViewportOf = F3(function(id, x, y)
  {
  	return _Browser_withNode(id, function(node)
  	{
  		node.scrollLeft = x;
  		node.scrollTop = y;
  		return _Utils_Tuple0;
  	});
  });
  
  
  
  // ELEMENT
  
  
  function _Browser_getElement(id)
  {
  	return _Browser_withNode(id, function(node)
  	{
  		var rect = node.getBoundingClientRect();
  		var x = _Browser_window.pageXOffset;
  		var y = _Browser_window.pageYOffset;
  		return {
  			cm: _Browser_getScene(),
  			cy: {
  				cB: x,
  				cC: y,
  				aJ: _Browser_doc.documentElement.clientWidth,
  				bS: _Browser_doc.documentElement.clientHeight
  			},
  			di: {
  				cB: x + rect.left,
  				cC: y + rect.top,
  				aJ: rect.width,
  				bS: rect.height
  			}
  		};
  	});
  }
  
  
  
  // LOAD and RELOAD
  
  
  function _Browser_reload(skipCache)
  {
  	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
  	{
  		_VirtualDom_doc.location.reload(skipCache);
  	}));
  }
  
  function _Browser_load(url)
  {
  	return A2($elm$core$Task$perform, $elm$core$Basics$never, _Scheduler_binding(function(callback)
  	{
  		try
  		{
  			_Browser_window.location = url;
  		}
  		catch(err)
  		{
  			// Only Firefox can throw a NS_ERROR_MALFORMED_URI exception here.
  			// Other browsers reload the page, so let's be consistent about that.
  			_VirtualDom_doc.location.reload(false);
  		}
  	}));
  }
  
  
  
  var _Bitwise_and = F2(function(a, b)
  {
  	return a & b;
  });
  
  var _Bitwise_or = F2(function(a, b)
  {
  	return a | b;
  });
  
  var _Bitwise_xor = F2(function(a, b)
  {
  	return a ^ b;
  });
  
  function _Bitwise_complement(a)
  {
  	return ~a;
  };
  
  var _Bitwise_shiftLeftBy = F2(function(offset, a)
  {
  	return a << offset;
  });
  
  var _Bitwise_shiftRightBy = F2(function(offset, a)
  {
  	return a >> offset;
  });
  
  var _Bitwise_shiftRightZfBy = F2(function(offset, a)
  {
  	return a >>> offset;
  });
  
  
  
  
  // STRINGS
  
  
  var _Parser_isSubString = F5(function(smallString, offset, row, col, bigString)
  {
  	var smallLength = smallString.length;
  	var isGood = offset + smallLength <= bigString.length;
  
  	for (var i = 0; isGood && i < smallLength; )
  	{
  		var code = bigString.charCodeAt(offset);
  		isGood =
  			smallString[i++] === bigString[offset++]
  			&& (
  				code === 0x000A /* \n */
  					? ( row++, col=1 )
  					: ( col++, (code & 0xF800) === 0xD800 ? smallString[i++] === bigString[offset++] : 1 )
  			)
  	}
  
  	return _Utils_Tuple3(isGood ? offset : -1, row, col);
  });
  
  
  
  // CHARS
  
  
  var _Parser_isSubChar = F3(function(predicate, offset, string)
  {
  	return (
  		string.length <= offset
  			? -1
  			:
  		(string.charCodeAt(offset) & 0xF800) === 0xD800
  			? (predicate(_Utils_chr(string.substr(offset, 2))) ? offset + 2 : -1)
  			:
  		(predicate(_Utils_chr(string[offset]))
  			? ((string[offset] === '\n') ? -2 : (offset + 1))
  			: -1
  		)
  	);
  });
  
  
  var _Parser_isAsciiCode = F3(function(code, offset, string)
  {
  	return string.charCodeAt(offset) === code;
  });
  
  
  
  // NUMBERS
  
  
  var _Parser_chompBase10 = F2(function(offset, string)
  {
  	for (; offset < string.length; offset++)
  	{
  		var code = string.charCodeAt(offset);
  		if (code < 0x30 || 0x39 < code)
  		{
  			return offset;
  		}
  	}
  	return offset;
  });
  
  
  var _Parser_consumeBase = F3(function(base, offset, string)
  {
  	for (var total = 0; offset < string.length; offset++)
  	{
  		var digit = string.charCodeAt(offset) - 0x30;
  		if (digit < 0 || base <= digit) break;
  		total = base * total + digit;
  	}
  	return _Utils_Tuple2(offset, total);
  });
  
  
  var _Parser_consumeBase16 = F2(function(offset, string)
  {
  	for (var total = 0; offset < string.length; offset++)
  	{
  		var code = string.charCodeAt(offset);
  		if (0x30 <= code && code <= 0x39)
  		{
  			total = 16 * total + code - 0x30;
  		}
  		else if (0x41 <= code && code <= 0x46)
  		{
  			total = 16 * total + code - 55;
  		}
  		else if (0x61 <= code && code <= 0x66)
  		{
  			total = 16 * total + code - 87;
  		}
  		else
  		{
  			break;
  		}
  	}
  	return _Utils_Tuple2(offset, total);
  });
  
  
  
  // FIND STRING
  
  
  var _Parser_findSubString = F5(function(smallString, offset, row, col, bigString)
  {
  	var newOffset = bigString.indexOf(smallString, offset);
  	var target = newOffset < 0 ? bigString.length : newOffset + smallString.length;
  
  	while (offset < target)
  	{
  		var code = bigString.charCodeAt(offset++);
  		code === 0x000A /* \n */
  			? ( col=1, row++ )
  			: ( col++, (code & 0xF800) === 0xD800 && offset++ )
  	}
  
  	return _Utils_Tuple3(newOffset, row, col);
  });
  
  
  
  function _Time_now(millisToPosix)
  {
  	return _Scheduler_binding(function(callback)
  	{
  		callback(_Scheduler_succeed(millisToPosix(Date.now())));
  	});
  }
  
  var _Time_setInterval = F2(function(interval, task)
  {
  	return _Scheduler_binding(function(callback)
  	{
  		var id = setInterval(function() { _Scheduler_rawSpawn(task); }, interval);
  		return function() { clearInterval(id); };
  	});
  });
  
  function _Time_here()
  {
  	return _Scheduler_binding(function(callback)
  	{
  		callback(_Scheduler_succeed(
  			A2($elm$time$Time$customZone, -(new Date().getTimezoneOffset()), _List_Nil)
  		));
  	});
  }
  
  
  function _Time_getZoneName()
  {
  	return _Scheduler_binding(function(callback)
  	{
  		try
  		{
  			var name = $elm$time$Time$Name(Intl.DateTimeFormat().resolvedOptions().timeZone);
  		}
  		catch (e)
  		{
  			var name = $elm$time$Time$Offset(new Date().getTimezoneOffset());
  		}
  		callback(_Scheduler_succeed(name));
  	});
  }
  var $elm$core$Basics$EQ = 1;
  var $elm$core$Basics$GT = 2;
  var $elm$core$Basics$LT = 0;
  var $elm$core$List$cons = _List_cons;
  var $elm$core$Dict$foldr = F3(
  	function (func, acc, t) {
  		foldr:
  		while (true) {
  			if (t.$ === -2) {
  				return acc;
  			} else {
  				var key = t.b;
  				var value = t.c;
  				var left = t.d;
  				var right = t.e;
  				var $temp$func = func,
  					$temp$acc = A3(
  					func,
  					key,
  					value,
  					A3($elm$core$Dict$foldr, func, acc, right)),
  					$temp$t = left;
  				func = $temp$func;
  				acc = $temp$acc;
  				t = $temp$t;
  				continue foldr;
  			}
  		}
  	});
  var $elm$core$Dict$toList = function (dict) {
  	return A3(
  		$elm$core$Dict$foldr,
  		F3(
  			function (key, value, list) {
  				return A2(
  					$elm$core$List$cons,
  					_Utils_Tuple2(key, value),
  					list);
  			}),
  		_List_Nil,
  		dict);
  };
  var $elm$core$Dict$keys = function (dict) {
  	return A3(
  		$elm$core$Dict$foldr,
  		F3(
  			function (key, value, keyList) {
  				return A2($elm$core$List$cons, key, keyList);
  			}),
  		_List_Nil,
  		dict);
  };
  var $elm$core$Set$toList = function (_v0) {
  	var dict = _v0;
  	return $elm$core$Dict$keys(dict);
  };
  var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;
  var $elm$core$Array$foldr = F3(
  	function (func, baseCase, _v0) {
  		var tree = _v0.c;
  		var tail = _v0.d;
  		var helper = F2(
  			function (node, acc) {
  				if (!node.$) {
  					var subTree = node.a;
  					return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
  				} else {
  					var values = node.a;
  					return A3($elm$core$Elm$JsArray$foldr, func, acc, values);
  				}
  			});
  		return A3(
  			$elm$core$Elm$JsArray$foldr,
  			helper,
  			A3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),
  			tree);
  	});
  var $elm$core$Array$toList = function (array) {
  	return A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);
  };
  var $elm$core$Result$Err = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$json$Json$Decode$Failure = F2(
  	function (a, b) {
  		return {$: 3, a: a, b: b};
  	});
  var $elm$json$Json$Decode$Field = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $elm$json$Json$Decode$Index = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $elm$core$Result$Ok = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$json$Json$Decode$OneOf = function (a) {
  	return {$: 2, a: a};
  };
  var $elm$core$Basics$False = 1;
  var $elm$core$Basics$add = _Basics_add;
  var $elm$core$Maybe$Just = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$core$Maybe$Nothing = {$: 1};
  var $elm$core$String$all = _String_all;
  var $elm$core$Basics$and = _Basics_and;
  var $elm$core$Basics$append = _Utils_append;
  var $elm$json$Json$Encode$encode = _Json_encode;
  var $elm$core$String$fromInt = _String_fromNumber;
  var $elm$core$String$join = F2(
  	function (sep, chunks) {
  		return A2(
  			_String_join,
  			sep,
  			_List_toArray(chunks));
  	});
  var $elm$core$String$split = F2(
  	function (sep, string) {
  		return _List_fromArray(
  			A2(_String_split, sep, string));
  	});
  var $elm$json$Json$Decode$indent = function (str) {
  	return A2(
  		$elm$core$String$join,
  		'\n    ',
  		A2($elm$core$String$split, '\n', str));
  };
  var $elm$core$List$foldl = F3(
  	function (func, acc, list) {
  		foldl:
  		while (true) {
  			if (!list.b) {
  				return acc;
  			} else {
  				var x = list.a;
  				var xs = list.b;
  				var $temp$func = func,
  					$temp$acc = A2(func, x, acc),
  					$temp$list = xs;
  				func = $temp$func;
  				acc = $temp$acc;
  				list = $temp$list;
  				continue foldl;
  			}
  		}
  	});
  var $elm$core$List$length = function (xs) {
  	return A3(
  		$elm$core$List$foldl,
  		F2(
  			function (_v0, i) {
  				return i + 1;
  			}),
  		0,
  		xs);
  };
  var $elm$core$List$map2 = _List_map2;
  var $elm$core$Basics$le = _Utils_le;
  var $elm$core$Basics$sub = _Basics_sub;
  var $elm$core$List$rangeHelp = F3(
  	function (lo, hi, list) {
  		rangeHelp:
  		while (true) {
  			if (_Utils_cmp(lo, hi) < 1) {
  				var $temp$lo = lo,
  					$temp$hi = hi - 1,
  					$temp$list = A2($elm$core$List$cons, hi, list);
  				lo = $temp$lo;
  				hi = $temp$hi;
  				list = $temp$list;
  				continue rangeHelp;
  			} else {
  				return list;
  			}
  		}
  	});
  var $elm$core$List$range = F2(
  	function (lo, hi) {
  		return A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);
  	});
  var $elm$core$List$indexedMap = F2(
  	function (f, xs) {
  		return A3(
  			$elm$core$List$map2,
  			f,
  			A2(
  				$elm$core$List$range,
  				0,
  				$elm$core$List$length(xs) - 1),
  			xs);
  	});
  var $elm$core$Char$toCode = _Char_toCode;
  var $elm$core$Char$isLower = function (_char) {
  	var code = $elm$core$Char$toCode(_char);
  	return (97 <= code) && (code <= 122);
  };
  var $elm$core$Char$isUpper = function (_char) {
  	var code = $elm$core$Char$toCode(_char);
  	return (code <= 90) && (65 <= code);
  };
  var $elm$core$Basics$or = _Basics_or;
  var $elm$core$Char$isAlpha = function (_char) {
  	return $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);
  };
  var $elm$core$Char$isDigit = function (_char) {
  	var code = $elm$core$Char$toCode(_char);
  	return (code <= 57) && (48 <= code);
  };
  var $elm$core$Char$isAlphaNum = function (_char) {
  	return $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));
  };
  var $elm$core$List$reverse = function (list) {
  	return A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);
  };
  var $elm$core$String$uncons = _String_uncons;
  var $elm$json$Json$Decode$errorOneOf = F2(
  	function (i, error) {
  		return '\n\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(
  			$elm$json$Json$Decode$errorToString(error))));
  	});
  var $elm$json$Json$Decode$errorToString = function (error) {
  	return A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);
  };
  var $elm$json$Json$Decode$errorToStringHelp = F2(
  	function (error, context) {
  		errorToStringHelp:
  		while (true) {
  			switch (error.$) {
  				case 0:
  					var f = error.a;
  					var err = error.b;
  					var isSimple = function () {
  						var _v1 = $elm$core$String$uncons(f);
  						if (_v1.$ === 1) {
  							return false;
  						} else {
  							var _v2 = _v1.a;
  							var _char = _v2.a;
  							var rest = _v2.b;
  							return $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);
  						}
  					}();
  					var fieldName = isSimple ? ('.' + f) : ('[\'' + (f + '\']'));
  					var $temp$error = err,
  						$temp$context = A2($elm$core$List$cons, fieldName, context);
  					error = $temp$error;
  					context = $temp$context;
  					continue errorToStringHelp;
  				case 1:
  					var i = error.a;
  					var err = error.b;
  					var indexName = '[' + ($elm$core$String$fromInt(i) + ']');
  					var $temp$error = err,
  						$temp$context = A2($elm$core$List$cons, indexName, context);
  					error = $temp$error;
  					context = $temp$context;
  					continue errorToStringHelp;
  				case 2:
  					var errors = error.a;
  					if (!errors.b) {
  						return 'Ran into a Json.Decode.oneOf with no possibilities' + function () {
  							if (!context.b) {
  								return '!';
  							} else {
  								return ' at json' + A2(
  									$elm$core$String$join,
  									'',
  									$elm$core$List$reverse(context));
  							}
  						}();
  					} else {
  						if (!errors.b.b) {
  							var err = errors.a;
  							var $temp$error = err,
  								$temp$context = context;
  							error = $temp$error;
  							context = $temp$context;
  							continue errorToStringHelp;
  						} else {
  							var starter = function () {
  								if (!context.b) {
  									return 'Json.Decode.oneOf';
  								} else {
  									return 'The Json.Decode.oneOf at json' + A2(
  										$elm$core$String$join,
  										'',
  										$elm$core$List$reverse(context));
  								}
  							}();
  							var introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(
  								$elm$core$List$length(errors)) + ' ways:'));
  							return A2(
  								$elm$core$String$join,
  								'\n\n',
  								A2(
  									$elm$core$List$cons,
  									introduction,
  									A2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));
  						}
  					}
  				default:
  					var msg = error.a;
  					var json = error.b;
  					var introduction = function () {
  						if (!context.b) {
  							return 'Problem with the given value:\n\n';
  						} else {
  							return 'Problem with the value at json' + (A2(
  								$elm$core$String$join,
  								'',
  								$elm$core$List$reverse(context)) + ':\n\n    ');
  						}
  					}();
  					return introduction + ($elm$json$Json$Decode$indent(
  						A2($elm$json$Json$Encode$encode, 4, json)) + ('\n\n' + msg));
  			}
  		}
  	});
  var $elm$core$Array$branchFactor = 32;
  var $elm$core$Array$Array_elm_builtin = F4(
  	function (a, b, c, d) {
  		return {$: 0, a: a, b: b, c: c, d: d};
  	});
  var $elm$core$Elm$JsArray$empty = _JsArray_empty;
  var $elm$core$Basics$ceiling = _Basics_ceiling;
  var $elm$core$Basics$fdiv = _Basics_fdiv;
  var $elm$core$Basics$logBase = F2(
  	function (base, number) {
  		return _Basics_log(number) / _Basics_log(base);
  	});
  var $elm$core$Basics$toFloat = _Basics_toFloat;
  var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(
  	A2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));
  var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);
  var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;
  var $elm$core$Array$Leaf = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$core$Basics$apL = F2(
  	function (f, x) {
  		return f(x);
  	});
  var $elm$core$Basics$apR = F2(
  	function (x, f) {
  		return f(x);
  	});
  var $elm$core$Basics$eq = _Utils_equal;
  var $elm$core$Basics$floor = _Basics_floor;
  var $elm$core$Elm$JsArray$length = _JsArray_length;
  var $elm$core$Basics$gt = _Utils_gt;
  var $elm$core$Basics$max = F2(
  	function (x, y) {
  		return (_Utils_cmp(x, y) > 0) ? x : y;
  	});
  var $elm$core$Basics$mul = _Basics_mul;
  var $elm$core$Array$SubTree = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;
  var $elm$core$Array$compressNodes = F2(
  	function (nodes, acc) {
  		compressNodes:
  		while (true) {
  			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);
  			var node = _v0.a;
  			var remainingNodes = _v0.b;
  			var newAcc = A2(
  				$elm$core$List$cons,
  				$elm$core$Array$SubTree(node),
  				acc);
  			if (!remainingNodes.b) {
  				return $elm$core$List$reverse(newAcc);
  			} else {
  				var $temp$nodes = remainingNodes,
  					$temp$acc = newAcc;
  				nodes = $temp$nodes;
  				acc = $temp$acc;
  				continue compressNodes;
  			}
  		}
  	});
  var $elm$core$Tuple$first = function (_v0) {
  	var x = _v0.a;
  	return x;
  };
  var $elm$core$Array$treeFromBuilder = F2(
  	function (nodeList, nodeListSize) {
  		treeFromBuilder:
  		while (true) {
  			var newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);
  			if (newNodeSize === 1) {
  				return A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;
  			} else {
  				var $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),
  					$temp$nodeListSize = newNodeSize;
  				nodeList = $temp$nodeList;
  				nodeListSize = $temp$nodeListSize;
  				continue treeFromBuilder;
  			}
  		}
  	});
  var $elm$core$Array$builderToArray = F2(
  	function (reverseNodeList, builder) {
  		if (!builder.f) {
  			return A4(
  				$elm$core$Array$Array_elm_builtin,
  				$elm$core$Elm$JsArray$length(builder.h),
  				$elm$core$Array$shiftStep,
  				$elm$core$Elm$JsArray$empty,
  				builder.h);
  		} else {
  			var treeLen = builder.f * $elm$core$Array$branchFactor;
  			var depth = $elm$core$Basics$floor(
  				A2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));
  			var correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.i) : builder.i;
  			var tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.f);
  			return A4(
  				$elm$core$Array$Array_elm_builtin,
  				$elm$core$Elm$JsArray$length(builder.h) + treeLen,
  				A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),
  				tree,
  				builder.h);
  		}
  	});
  var $elm$core$Basics$idiv = _Basics_idiv;
  var $elm$core$Basics$lt = _Utils_lt;
  var $elm$core$Array$initializeHelp = F5(
  	function (fn, fromIndex, len, nodeList, tail) {
  		initializeHelp:
  		while (true) {
  			if (fromIndex < 0) {
  				return A2(
  					$elm$core$Array$builderToArray,
  					false,
  					{i: nodeList, f: (len / $elm$core$Array$branchFactor) | 0, h: tail});
  			} else {
  				var leaf = $elm$core$Array$Leaf(
  					A3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));
  				var $temp$fn = fn,
  					$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,
  					$temp$len = len,
  					$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),
  					$temp$tail = tail;
  				fn = $temp$fn;
  				fromIndex = $temp$fromIndex;
  				len = $temp$len;
  				nodeList = $temp$nodeList;
  				tail = $temp$tail;
  				continue initializeHelp;
  			}
  		}
  	});
  var $elm$core$Basics$remainderBy = _Basics_remainderBy;
  var $elm$core$Array$initialize = F2(
  	function (len, fn) {
  		if (len <= 0) {
  			return $elm$core$Array$empty;
  		} else {
  			var tailLen = len % $elm$core$Array$branchFactor;
  			var tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);
  			var initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;
  			return A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);
  		}
  	});
  var $elm$core$Basics$True = 0;
  var $elm$core$Result$isOk = function (result) {
  	if (!result.$) {
  		return true;
  	} else {
  		return false;
  	}
  };
  var $elm$json$Json$Decode$map = _Json_map1;
  var $elm$json$Json$Decode$map2 = _Json_map2;
  var $elm$json$Json$Decode$succeed = _Json_succeed;
  var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {
  	switch (handler.$) {
  		case 0:
  			return 0;
  		case 1:
  			return 1;
  		case 2:
  			return 2;
  		default:
  			return 3;
  	}
  };
  var $elm$browser$Browser$External = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$browser$Browser$Internal = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$core$Basics$identity = function (x) {
  	return x;
  };
  var $elm$browser$Browser$Dom$NotFound = $elm$core$Basics$identity;
  var $elm$url$Url$Http = 0;
  var $elm$url$Url$Https = 1;
  var $elm$url$Url$Url = F6(
  	function (protocol, host, port_, path, query, fragment) {
  		return {bQ: fragment, bW: host, cc: path, cf: port_, ci: protocol, cj: query};
  	});
  var $elm$core$String$contains = _String_contains;
  var $elm$core$String$length = _String_length;
  var $elm$core$String$slice = _String_slice;
  var $elm$core$String$dropLeft = F2(
  	function (n, string) {
  		return (n < 1) ? string : A3(
  			$elm$core$String$slice,
  			n,
  			$elm$core$String$length(string),
  			string);
  	});
  var $elm$core$String$indexes = _String_indexes;
  var $elm$core$String$isEmpty = function (string) {
  	return string === '';
  };
  var $elm$core$String$left = F2(
  	function (n, string) {
  		return (n < 1) ? '' : A3($elm$core$String$slice, 0, n, string);
  	});
  var $elm$core$String$toInt = _String_toInt;
  var $elm$url$Url$chompBeforePath = F5(
  	function (protocol, path, params, frag, str) {
  		if ($elm$core$String$isEmpty(str) || A2($elm$core$String$contains, '@', str)) {
  			return $elm$core$Maybe$Nothing;
  		} else {
  			var _v0 = A2($elm$core$String$indexes, ':', str);
  			if (!_v0.b) {
  				return $elm$core$Maybe$Just(
  					A6($elm$url$Url$Url, protocol, str, $elm$core$Maybe$Nothing, path, params, frag));
  			} else {
  				if (!_v0.b.b) {
  					var i = _v0.a;
  					var _v1 = $elm$core$String$toInt(
  						A2($elm$core$String$dropLeft, i + 1, str));
  					if (_v1.$ === 1) {
  						return $elm$core$Maybe$Nothing;
  					} else {
  						var port_ = _v1;
  						return $elm$core$Maybe$Just(
  							A6(
  								$elm$url$Url$Url,
  								protocol,
  								A2($elm$core$String$left, i, str),
  								port_,
  								path,
  								params,
  								frag));
  					}
  				} else {
  					return $elm$core$Maybe$Nothing;
  				}
  			}
  		}
  	});
  var $elm$url$Url$chompBeforeQuery = F4(
  	function (protocol, params, frag, str) {
  		if ($elm$core$String$isEmpty(str)) {
  			return $elm$core$Maybe$Nothing;
  		} else {
  			var _v0 = A2($elm$core$String$indexes, '/', str);
  			if (!_v0.b) {
  				return A5($elm$url$Url$chompBeforePath, protocol, '/', params, frag, str);
  			} else {
  				var i = _v0.a;
  				return A5(
  					$elm$url$Url$chompBeforePath,
  					protocol,
  					A2($elm$core$String$dropLeft, i, str),
  					params,
  					frag,
  					A2($elm$core$String$left, i, str));
  			}
  		}
  	});
  var $elm$url$Url$chompBeforeFragment = F3(
  	function (protocol, frag, str) {
  		if ($elm$core$String$isEmpty(str)) {
  			return $elm$core$Maybe$Nothing;
  		} else {
  			var _v0 = A2($elm$core$String$indexes, '?', str);
  			if (!_v0.b) {
  				return A4($elm$url$Url$chompBeforeQuery, protocol, $elm$core$Maybe$Nothing, frag, str);
  			} else {
  				var i = _v0.a;
  				return A4(
  					$elm$url$Url$chompBeforeQuery,
  					protocol,
  					$elm$core$Maybe$Just(
  						A2($elm$core$String$dropLeft, i + 1, str)),
  					frag,
  					A2($elm$core$String$left, i, str));
  			}
  		}
  	});
  var $elm$url$Url$chompAfterProtocol = F2(
  	function (protocol, str) {
  		if ($elm$core$String$isEmpty(str)) {
  			return $elm$core$Maybe$Nothing;
  		} else {
  			var _v0 = A2($elm$core$String$indexes, '#', str);
  			if (!_v0.b) {
  				return A3($elm$url$Url$chompBeforeFragment, protocol, $elm$core$Maybe$Nothing, str);
  			} else {
  				var i = _v0.a;
  				return A3(
  					$elm$url$Url$chompBeforeFragment,
  					protocol,
  					$elm$core$Maybe$Just(
  						A2($elm$core$String$dropLeft, i + 1, str)),
  					A2($elm$core$String$left, i, str));
  			}
  		}
  	});
  var $elm$core$String$startsWith = _String_startsWith;
  var $elm$url$Url$fromString = function (str) {
  	return A2($elm$core$String$startsWith, 'http://', str) ? A2(
  		$elm$url$Url$chompAfterProtocol,
  		0,
  		A2($elm$core$String$dropLeft, 7, str)) : (A2($elm$core$String$startsWith, 'https://', str) ? A2(
  		$elm$url$Url$chompAfterProtocol,
  		1,
  		A2($elm$core$String$dropLeft, 8, str)) : $elm$core$Maybe$Nothing);
  };
  var $elm$core$Basics$never = function (_v0) {
  	never:
  	while (true) {
  		var nvr = _v0;
  		var $temp$_v0 = nvr;
  		_v0 = $temp$_v0;
  		continue never;
  	}
  };
  var $elm$core$Task$Perform = $elm$core$Basics$identity;
  var $elm$core$Task$succeed = _Scheduler_succeed;
  var $elm$core$Task$init = $elm$core$Task$succeed(0);
  var $elm$core$List$foldrHelper = F4(
  	function (fn, acc, ctr, ls) {
  		if (!ls.b) {
  			return acc;
  		} else {
  			var a = ls.a;
  			var r1 = ls.b;
  			if (!r1.b) {
  				return A2(fn, a, acc);
  			} else {
  				var b = r1.a;
  				var r2 = r1.b;
  				if (!r2.b) {
  					return A2(
  						fn,
  						a,
  						A2(fn, b, acc));
  				} else {
  					var c = r2.a;
  					var r3 = r2.b;
  					if (!r3.b) {
  						return A2(
  							fn,
  							a,
  							A2(
  								fn,
  								b,
  								A2(fn, c, acc)));
  					} else {
  						var d = r3.a;
  						var r4 = r3.b;
  						var res = (ctr > 500) ? A3(
  							$elm$core$List$foldl,
  							fn,
  							acc,
  							$elm$core$List$reverse(r4)) : A4($elm$core$List$foldrHelper, fn, acc, ctr + 1, r4);
  						return A2(
  							fn,
  							a,
  							A2(
  								fn,
  								b,
  								A2(
  									fn,
  									c,
  									A2(fn, d, res))));
  					}
  				}
  			}
  		}
  	});
  var $elm$core$List$foldr = F3(
  	function (fn, acc, ls) {
  		return A4($elm$core$List$foldrHelper, fn, acc, 0, ls);
  	});
  var $elm$core$List$map = F2(
  	function (f, xs) {
  		return A3(
  			$elm$core$List$foldr,
  			F2(
  				function (x, acc) {
  					return A2(
  						$elm$core$List$cons,
  						f(x),
  						acc);
  				}),
  			_List_Nil,
  			xs);
  	});
  var $elm$core$Task$andThen = _Scheduler_andThen;
  var $elm$core$Task$map = F2(
  	function (func, taskA) {
  		return A2(
  			$elm$core$Task$andThen,
  			function (a) {
  				return $elm$core$Task$succeed(
  					func(a));
  			},
  			taskA);
  	});
  var $elm$core$Task$map2 = F3(
  	function (func, taskA, taskB) {
  		return A2(
  			$elm$core$Task$andThen,
  			function (a) {
  				return A2(
  					$elm$core$Task$andThen,
  					function (b) {
  						return $elm$core$Task$succeed(
  							A2(func, a, b));
  					},
  					taskB);
  			},
  			taskA);
  	});
  var $elm$core$Task$sequence = function (tasks) {
  	return A3(
  		$elm$core$List$foldr,
  		$elm$core$Task$map2($elm$core$List$cons),
  		$elm$core$Task$succeed(_List_Nil),
  		tasks);
  };
  var $elm$core$Platform$sendToApp = _Platform_sendToApp;
  var $elm$core$Task$spawnCmd = F2(
  	function (router, _v0) {
  		var task = _v0;
  		return _Scheduler_spawn(
  			A2(
  				$elm$core$Task$andThen,
  				$elm$core$Platform$sendToApp(router),
  				task));
  	});
  var $elm$core$Task$onEffects = F3(
  	function (router, commands, state) {
  		return A2(
  			$elm$core$Task$map,
  			function (_v0) {
  				return 0;
  			},
  			$elm$core$Task$sequence(
  				A2(
  					$elm$core$List$map,
  					$elm$core$Task$spawnCmd(router),
  					commands)));
  	});
  var $elm$core$Task$onSelfMsg = F3(
  	function (_v0, _v1, _v2) {
  		return $elm$core$Task$succeed(0);
  	});
  var $elm$core$Task$cmdMap = F2(
  	function (tagger, _v0) {
  		var task = _v0;
  		return A2($elm$core$Task$map, tagger, task);
  	});
  _Platform_effectManagers['Task'] = _Platform_createManager($elm$core$Task$init, $elm$core$Task$onEffects, $elm$core$Task$onSelfMsg, $elm$core$Task$cmdMap);
  var $elm$core$Task$command = _Platform_leaf('Task');
  var $elm$core$Task$perform = F2(
  	function (toMessage, task) {
  		return $elm$core$Task$command(
  			A2($elm$core$Task$map, toMessage, task));
  	});
  var $elm$browser$Browser$element = _Browser_element;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$Bottom = 1;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$Model = $elm$core$Basics$identity;
  var $elm$time$Time$Posix = $elm$core$Basics$identity;
  var $elm$time$Time$millisToPosix = $elm$core$Basics$identity;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$init = function (loadMoreFunc) {
  	return {
  		au: 1,
  		aj: false,
  		aU: $elm$time$Time$millisToPosix(0),
  		aV: loadMoreFunc,
  		ay: 50,
  		a2: 5 * 1000
  	};
  };
  var $author$project$CpuEmulator$LoadedMoreRam = {$: 15};
  var $author$project$CpuEmulator$msgToCmd = function (x) {
  	return A2(
  		$elm$core$Task$perform,
  		$elm$core$Basics$identity,
  		$elm$core$Task$succeed(x));
  };
  var $author$project$CpuEmulator$loadMoreRam = function (_v0) {
  	return $author$project$CpuEmulator$msgToCmd($author$project$CpuEmulator$LoadedMoreRam);
  };
  var $author$project$CpuEmulator$LoadedMoreRom = {$: 17};
  var $author$project$CpuEmulator$loadMoreRom = function (_v0) {
  	return $author$project$CpuEmulator$msgToCmd($author$project$CpuEmulator$LoadedMoreRom);
  };
  var $elm$core$Platform$Cmd$batch = _Platform_batch;
  var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
  var $elm$core$Basics$pow = _Basics_pow;
  var $elm$core$Array$repeat = F2(
  	function (n, e) {
  		return A2(
  			$elm$core$Array$initialize,
  			n,
  			function (_v0) {
  				return e;
  			});
  	});
  var $author$project$CpuEmulator$init = function (_v0) {
  	return _Utils_Tuple2(
  		{
  			a9: $elm$core$Maybe$Nothing,
  			d: {
  				r: 0,
  				ag: 0,
  				K: $elm$core$Maybe$Nothing,
  				X: 0,
  				l: 0,
  				O: A2(
  					$elm$core$Array$repeat,
  					A2($elm$core$Basics$pow, 2, 16),
  					0),
  				am: A2(
  					$elm$core$Array$repeat,
  					A2($elm$core$Basics$pow, 2, 16),
  					0),
  				Q: _List_Nil
  			},
  			av: $elm$core$Maybe$Nothing,
  			aw: $elm$core$Maybe$Nothing,
  			C: A2(
  				$elm$core$Array$repeat,
  				A2($elm$core$Basics$pow, 2, 16),
  				''),
  			w: true,
  			ai: false,
  			V: false,
  			aA: '',
  			aB: 50,
  			al: $FabienHenon$elm_infinite_scroll$InfiniteScroll$init($author$project$CpuEmulator$loadMoreRam),
  			aC: 50,
  			an: $FabienHenon$elm_infinite_scroll$InfiniteScroll$init($author$project$CpuEmulator$loadMoreRom)
  		},
  		$elm$core$Platform$Cmd$none);
  };
  var $author$project$CpuEmulator$EditProgram = function (a) {
  	return {$: 9, a: a};
  };
  var $author$project$CpuEmulator$StepComputerOneFrame = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$core$Platform$Sub$batch = _Platform_batch;
  var $elm$json$Json$Decode$string = _Json_decodeString;
  var $author$project$CpuEmulator$editProgramPort = _Platform_incomingPort('editProgramPort', $elm$json$Json$Decode$string);
  var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
  var $elm$browser$Browser$AnimationManager$Delta = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$browser$Browser$AnimationManager$State = F3(
  	function (subs, request, oldTime) {
  		return {bo: oldTime, cl: request, cr: subs};
  	});
  var $elm$browser$Browser$AnimationManager$init = $elm$core$Task$succeed(
  	A3($elm$browser$Browser$AnimationManager$State, _List_Nil, $elm$core$Maybe$Nothing, 0));
  var $elm$core$Process$kill = _Scheduler_kill;
  var $elm$browser$Browser$AnimationManager$now = _Browser_now(0);
  var $elm$browser$Browser$AnimationManager$rAF = _Browser_rAF(0);
  var $elm$core$Platform$sendToSelf = _Platform_sendToSelf;
  var $elm$core$Process$spawn = _Scheduler_spawn;
  var $elm$browser$Browser$AnimationManager$onEffects = F3(
  	function (router, subs, _v0) {
  		var request = _v0.cl;
  		var oldTime = _v0.bo;
  		var _v1 = _Utils_Tuple2(request, subs);
  		if (_v1.a.$ === 1) {
  			if (!_v1.b.b) {
  				var _v2 = _v1.a;
  				return $elm$browser$Browser$AnimationManager$init;
  			} else {
  				var _v4 = _v1.a;
  				return A2(
  					$elm$core$Task$andThen,
  					function (pid) {
  						return A2(
  							$elm$core$Task$andThen,
  							function (time) {
  								return $elm$core$Task$succeed(
  									A3(
  										$elm$browser$Browser$AnimationManager$State,
  										subs,
  										$elm$core$Maybe$Just(pid),
  										time));
  							},
  							$elm$browser$Browser$AnimationManager$now);
  					},
  					$elm$core$Process$spawn(
  						A2(
  							$elm$core$Task$andThen,
  							$elm$core$Platform$sendToSelf(router),
  							$elm$browser$Browser$AnimationManager$rAF)));
  			}
  		} else {
  			if (!_v1.b.b) {
  				var pid = _v1.a.a;
  				return A2(
  					$elm$core$Task$andThen,
  					function (_v3) {
  						return $elm$browser$Browser$AnimationManager$init;
  					},
  					$elm$core$Process$kill(pid));
  			} else {
  				return $elm$core$Task$succeed(
  					A3($elm$browser$Browser$AnimationManager$State, subs, request, oldTime));
  			}
  		}
  	});
  var $elm$browser$Browser$AnimationManager$onSelfMsg = F3(
  	function (router, newTime, _v0) {
  		var subs = _v0.cr;
  		var oldTime = _v0.bo;
  		var send = function (sub) {
  			if (!sub.$) {
  				var tagger = sub.a;
  				return A2(
  					$elm$core$Platform$sendToApp,
  					router,
  					tagger(
  						$elm$time$Time$millisToPosix(newTime)));
  			} else {
  				var tagger = sub.a;
  				return A2(
  					$elm$core$Platform$sendToApp,
  					router,
  					tagger(newTime - oldTime));
  			}
  		};
  		return A2(
  			$elm$core$Task$andThen,
  			function (pid) {
  				return A2(
  					$elm$core$Task$andThen,
  					function (_v1) {
  						return $elm$core$Task$succeed(
  							A3(
  								$elm$browser$Browser$AnimationManager$State,
  								subs,
  								$elm$core$Maybe$Just(pid),
  								newTime));
  					},
  					$elm$core$Task$sequence(
  						A2($elm$core$List$map, send, subs)));
  			},
  			$elm$core$Process$spawn(
  				A2(
  					$elm$core$Task$andThen,
  					$elm$core$Platform$sendToSelf(router),
  					$elm$browser$Browser$AnimationManager$rAF)));
  	});
  var $elm$browser$Browser$AnimationManager$Time = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$core$Basics$composeL = F3(
  	function (g, f, x) {
  		return g(
  			f(x));
  	});
  var $elm$browser$Browser$AnimationManager$subMap = F2(
  	function (func, sub) {
  		if (!sub.$) {
  			var tagger = sub.a;
  			return $elm$browser$Browser$AnimationManager$Time(
  				A2($elm$core$Basics$composeL, func, tagger));
  		} else {
  			var tagger = sub.a;
  			return $elm$browser$Browser$AnimationManager$Delta(
  				A2($elm$core$Basics$composeL, func, tagger));
  		}
  	});
  _Platform_effectManagers['Browser.AnimationManager'] = _Platform_createManager($elm$browser$Browser$AnimationManager$init, $elm$browser$Browser$AnimationManager$onEffects, $elm$browser$Browser$AnimationManager$onSelfMsg, 0, $elm$browser$Browser$AnimationManager$subMap);
  var $elm$browser$Browser$AnimationManager$subscription = _Platform_leaf('Browser.AnimationManager');
  var $elm$browser$Browser$AnimationManager$onAnimationFrameDelta = function (tagger) {
  	return $elm$browser$Browser$AnimationManager$subscription(
  		$elm$browser$Browser$AnimationManager$Delta(tagger));
  };
  var $elm$browser$Browser$Events$onAnimationFrameDelta = $elm$browser$Browser$AnimationManager$onAnimationFrameDelta;
  var $author$project$CpuEmulator$subscriptions = function (model) {
  	return $elm$core$Platform$Sub$batch(
  		_List_fromArray(
  			[
  				$author$project$CpuEmulator$editProgramPort($author$project$CpuEmulator$EditProgram),
  				model.V ? $elm$browser$Browser$Events$onAnimationFrameDelta($author$project$CpuEmulator$StepComputerOneFrame) : $elm$core$Platform$Sub$none
  			]));
  };
  var $author$project$CpuEmulator$RamScrollMsg = function (a) {
  	return {$: 14, a: a};
  };
  var $author$project$CpuEmulator$RomScrollMsg = function (a) {
  	return {$: 16, a: a};
  };
  var $elm$core$Bitwise$and = _Bitwise_and;
  var $elm$core$Bitwise$shiftRightZfBy = _Bitwise_shiftRightZfBy;
  var $elm$core$Array$bitMask = 4294967295 >>> (32 - $elm$core$Array$shiftStep);
  var $elm$core$Basics$ge = _Utils_ge;
  var $elm$core$Elm$JsArray$unsafeGet = _JsArray_unsafeGet;
  var $elm$core$Elm$JsArray$unsafeSet = _JsArray_unsafeSet;
  var $elm$core$Array$setHelp = F4(
  	function (shift, index, value, tree) {
  		var pos = $elm$core$Array$bitMask & (index >>> shift);
  		var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
  		if (!_v0.$) {
  			var subTree = _v0.a;
  			var newSub = A4($elm$core$Array$setHelp, shift - $elm$core$Array$shiftStep, index, value, subTree);
  			return A3(
  				$elm$core$Elm$JsArray$unsafeSet,
  				pos,
  				$elm$core$Array$SubTree(newSub),
  				tree);
  		} else {
  			var values = _v0.a;
  			var newLeaf = A3($elm$core$Elm$JsArray$unsafeSet, $elm$core$Array$bitMask & index, value, values);
  			return A3(
  				$elm$core$Elm$JsArray$unsafeSet,
  				pos,
  				$elm$core$Array$Leaf(newLeaf),
  				tree);
  		}
  	});
  var $elm$core$Bitwise$shiftLeftBy = _Bitwise_shiftLeftBy;
  var $elm$core$Array$tailIndex = function (len) {
  	return (len >>> 5) << 5;
  };
  var $elm$core$Array$set = F3(
  	function (index, value, array) {
  		var len = array.a;
  		var startShift = array.b;
  		var tree = array.c;
  		var tail = array.d;
  		return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? array : ((_Utils_cmp(
  			index,
  			$elm$core$Array$tailIndex(len)) > -1) ? A4(
  			$elm$core$Array$Array_elm_builtin,
  			len,
  			startShift,
  			tree,
  			A3($elm$core$Elm$JsArray$unsafeSet, $elm$core$Array$bitMask & index, value, tail)) : A4(
  			$elm$core$Array$Array_elm_builtin,
  			len,
  			startShift,
  			A4($elm$core$Array$setHelp, startShift, index, value, tree),
  			tail));
  	});
  var $author$project$CpuEmulator$editInstruction = F3(
  	function (index, newInstruction, model) {
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{
  					C: A3($elm$core$Array$set, index, newInstruction, model.C)
  				}),
  			$elm$core$Platform$Cmd$none);
  	});
  var $elm$json$Json$Encode$null = _Json_encodeNull;
  var $author$project$CpuEmulator$clearAssemblerErrorPort = _Platform_outgoingPort(
  	'clearAssemblerErrorPort',
  	function ($) {
  		return $elm$json$Json$Encode$null;
  	});
  var $author$project$AsmParser$AInstruction = function (a) {
  	return {$: 0, a: a};
  };
  var $author$project$AsmParser$CInstruction = function (a) {
  	return {$: 1, a: a};
  };
  var $author$project$AsmParser$ExpectingEOF = {$: 8};
  var $author$project$AsmParser$UndefinedSymbol = function (a) {
  	return {$: 19, a: a};
  };
  var $elm$core$Result$andThen = F2(
  	function (callback, result) {
  		if (!result.$) {
  			var value = result.a;
  			return callback(value);
  		} else {
  			var msg = result.a;
  			return $elm$core$Result$Err(msg);
  		}
  	});
  var $elm$parser$Parser$Advanced$Bad = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $elm$parser$Parser$Advanced$Good = F3(
  	function (a, b, c) {
  		return {$: 0, a: a, b: b, c: c};
  	});
  var $elm$parser$Parser$Advanced$Parser = $elm$core$Basics$identity;
  var $elm$parser$Parser$Advanced$AddRight = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $elm$parser$Parser$Advanced$DeadEnd = F4(
  	function (row, col, problem, contextStack) {
  		return {aO: col, bJ: contextStack, bq: problem, aX: row};
  	});
  var $elm$parser$Parser$Advanced$Empty = {$: 0};
  var $elm$parser$Parser$Advanced$fromState = F2(
  	function (s, x) {
  		return A2(
  			$elm$parser$Parser$Advanced$AddRight,
  			$elm$parser$Parser$Advanced$Empty,
  			A4($elm$parser$Parser$Advanced$DeadEnd, s.aX, s.aO, x, s.da));
  	});
  var $elm$parser$Parser$Advanced$end = function (x) {
  	return function (s) {
  		return _Utils_eq(
  			$elm$core$String$length(s.a),
  			s.ay) ? A3($elm$parser$Parser$Advanced$Good, false, 0, s) : A2(
  			$elm$parser$Parser$Advanced$Bad,
  			false,
  			A2($elm$parser$Parser$Advanced$fromState, s, x));
  	};
  };
  var $Gizra$elm_all_set$EverySet$EverySet = $elm$core$Basics$identity;
  var $pzp1997$assoc_list$AssocList$D = $elm$core$Basics$identity;
  var $pzp1997$assoc_list$AssocList$empty = _List_Nil;
  var $Gizra$elm_all_set$EverySet$empty = $pzp1997$assoc_list$AssocList$empty;
  var $elm$core$List$filter = F2(
  	function (isGood, list) {
  		return A3(
  			$elm$core$List$foldr,
  			F2(
  				function (x, xs) {
  					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
  				}),
  			_List_Nil,
  			list);
  	});
  var $elm$core$Basics$neq = _Utils_notEqual;
  var $pzp1997$assoc_list$AssocList$remove = F2(
  	function (targetKey, _v0) {
  		var alist = _v0;
  		return A2(
  			$elm$core$List$filter,
  			function (_v1) {
  				var key = _v1.a;
  				return !_Utils_eq(key, targetKey);
  			},
  			alist);
  	});
  var $pzp1997$assoc_list$AssocList$insert = F3(
  	function (key, value, dict) {
  		var _v0 = A2($pzp1997$assoc_list$AssocList$remove, key, dict);
  		var alteredAlist = _v0;
  		return A2(
  			$elm$core$List$cons,
  			_Utils_Tuple2(key, value),
  			alteredAlist);
  	});
  var $Gizra$elm_all_set$EverySet$insert = F2(
  	function (k, _v0) {
  		var d = _v0;
  		return A3($pzp1997$assoc_list$AssocList$insert, k, 0, d);
  	});
  var $Gizra$elm_all_set$EverySet$fromList = function (xs) {
  	return A3($elm$core$List$foldl, $Gizra$elm_all_set$EverySet$insert, $Gizra$elm_all_set$EverySet$empty, xs);
  };
  var $elm$core$Set$Set_elm_builtin = $elm$core$Basics$identity;
  var $elm$core$Dict$RBEmpty_elm_builtin = {$: -2};
  var $elm$core$Dict$empty = $elm$core$Dict$RBEmpty_elm_builtin;
  var $elm$core$Set$empty = $elm$core$Dict$empty;
  var $elm$core$Dict$Black = 1;
  var $elm$core$Dict$RBNode_elm_builtin = F5(
  	function (a, b, c, d, e) {
  		return {$: -1, a: a, b: b, c: c, d: d, e: e};
  	});
  var $elm$core$Dict$Red = 0;
  var $elm$core$Dict$balance = F5(
  	function (color, key, value, left, right) {
  		if ((right.$ === -1) && (!right.a)) {
  			var _v1 = right.a;
  			var rK = right.b;
  			var rV = right.c;
  			var rLeft = right.d;
  			var rRight = right.e;
  			if ((left.$ === -1) && (!left.a)) {
  				var _v3 = left.a;
  				var lK = left.b;
  				var lV = left.c;
  				var lLeft = left.d;
  				var lRight = left.e;
  				return A5(
  					$elm$core$Dict$RBNode_elm_builtin,
  					0,
  					key,
  					value,
  					A5($elm$core$Dict$RBNode_elm_builtin, 1, lK, lV, lLeft, lRight),
  					A5($elm$core$Dict$RBNode_elm_builtin, 1, rK, rV, rLeft, rRight));
  			} else {
  				return A5(
  					$elm$core$Dict$RBNode_elm_builtin,
  					color,
  					rK,
  					rV,
  					A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, left, rLeft),
  					rRight);
  			}
  		} else {
  			if ((((left.$ === -1) && (!left.a)) && (left.d.$ === -1)) && (!left.d.a)) {
  				var _v5 = left.a;
  				var lK = left.b;
  				var lV = left.c;
  				var _v6 = left.d;
  				var _v7 = _v6.a;
  				var llK = _v6.b;
  				var llV = _v6.c;
  				var llLeft = _v6.d;
  				var llRight = _v6.e;
  				var lRight = left.e;
  				return A5(
  					$elm$core$Dict$RBNode_elm_builtin,
  					0,
  					lK,
  					lV,
  					A5($elm$core$Dict$RBNode_elm_builtin, 1, llK, llV, llLeft, llRight),
  					A5($elm$core$Dict$RBNode_elm_builtin, 1, key, value, lRight, right));
  			} else {
  				return A5($elm$core$Dict$RBNode_elm_builtin, color, key, value, left, right);
  			}
  		}
  	});
  var $elm$core$Basics$compare = _Utils_compare;
  var $elm$core$Dict$insertHelp = F3(
  	function (key, value, dict) {
  		if (dict.$ === -2) {
  			return A5($elm$core$Dict$RBNode_elm_builtin, 0, key, value, $elm$core$Dict$RBEmpty_elm_builtin, $elm$core$Dict$RBEmpty_elm_builtin);
  		} else {
  			var nColor = dict.a;
  			var nKey = dict.b;
  			var nValue = dict.c;
  			var nLeft = dict.d;
  			var nRight = dict.e;
  			var _v1 = A2($elm$core$Basics$compare, key, nKey);
  			switch (_v1) {
  				case 0:
  					return A5(
  						$elm$core$Dict$balance,
  						nColor,
  						nKey,
  						nValue,
  						A3($elm$core$Dict$insertHelp, key, value, nLeft),
  						nRight);
  				case 1:
  					return A5($elm$core$Dict$RBNode_elm_builtin, nColor, nKey, value, nLeft, nRight);
  				default:
  					return A5(
  						$elm$core$Dict$balance,
  						nColor,
  						nKey,
  						nValue,
  						nLeft,
  						A3($elm$core$Dict$insertHelp, key, value, nRight));
  			}
  		}
  	});
  var $elm$core$Dict$insert = F3(
  	function (key, value, dict) {
  		var _v0 = A3($elm$core$Dict$insertHelp, key, value, dict);
  		if ((_v0.$ === -1) && (!_v0.a)) {
  			var _v1 = _v0.a;
  			var k = _v0.b;
  			var v = _v0.c;
  			var l = _v0.d;
  			var r = _v0.e;
  			return A5($elm$core$Dict$RBNode_elm_builtin, 1, k, v, l, r);
  		} else {
  			var x = _v0;
  			return x;
  		}
  	});
  var $elm$core$Set$insert = F2(
  	function (key, _v0) {
  		var dict = _v0;
  		return A3($elm$core$Dict$insert, key, 0, dict);
  	});
  var $elm$core$Set$fromList = function (list) {
  	return A3($elm$core$List$foldl, $elm$core$Set$insert, $elm$core$Set$empty, list);
  };
  var $elm$core$Dict$get = F2(
  	function (targetKey, dict) {
  		get:
  		while (true) {
  			if (dict.$ === -2) {
  				return $elm$core$Maybe$Nothing;
  			} else {
  				var key = dict.b;
  				var value = dict.c;
  				var left = dict.d;
  				var right = dict.e;
  				var _v1 = A2($elm$core$Basics$compare, targetKey, key);
  				switch (_v1) {
  					case 0:
  						var $temp$targetKey = targetKey,
  							$temp$dict = left;
  						targetKey = $temp$targetKey;
  						dict = $temp$dict;
  						continue get;
  					case 1:
  						return $elm$core$Maybe$Just(value);
  					default:
  						var $temp$targetKey = targetKey,
  							$temp$dict = right;
  						targetKey = $temp$targetKey;
  						dict = $temp$dict;
  						continue get;
  				}
  			}
  		}
  	});
  var $elm$core$Basics$always = F2(
  	function (a, _v0) {
  		return a;
  	});
  var $elm$parser$Parser$Advanced$map2 = F3(
  	function (func, _v0, _v1) {
  		var parseA = _v0;
  		var parseB = _v1;
  		return function (s0) {
  			var _v2 = parseA(s0);
  			if (_v2.$ === 1) {
  				var p = _v2.a;
  				var x = _v2.b;
  				return A2($elm$parser$Parser$Advanced$Bad, p, x);
  			} else {
  				var p1 = _v2.a;
  				var a = _v2.b;
  				var s1 = _v2.c;
  				var _v3 = parseB(s1);
  				if (_v3.$ === 1) {
  					var p2 = _v3.a;
  					var x = _v3.b;
  					return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x);
  				} else {
  					var p2 = _v3.a;
  					var b = _v3.b;
  					var s2 = _v3.c;
  					return A3(
  						$elm$parser$Parser$Advanced$Good,
  						p1 || p2,
  						A2(func, a, b),
  						s2);
  				}
  			}
  		};
  	});
  var $elm$parser$Parser$Advanced$ignorer = F2(
  	function (keepParser, ignoreParser) {
  		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$always, keepParser, ignoreParser);
  	});
  var $elm$parser$Parser$Advanced$Done = function (a) {
  	return {$: 1, a: a};
  };
  var $author$project$AsmParser$ExpectingInstruction = {$: 9};
  var $elm$parser$Parser$Advanced$Loop = function (a) {
  	return {$: 0, a: a};
  };
  var $author$project$AsmParser$AContext = 0;
  var $author$project$AsmParser$ExpectingAtSign = {$: 0};
  var $author$project$AsmParser$ExpectingInt = {$: 10};
  var $author$project$AsmParser$InvalidNumber = {$: 17};
  var $author$project$AsmParser$NumberTooLarge = function (a) {
  	return {$: 18, a: a};
  };
  var $author$project$AsmParser$ParserAInstruction = function (a) {
  	return {$: 0, a: a};
  };
  var $author$project$AsmParser$ParserAInstructionLabel = function (a) {
  	return {$: 1, a: a};
  };
  var $author$project$AsmParser$ParserAInstructionNumber = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$parser$Parser$Advanced$Token = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $elm$parser$Parser$Advanced$andThen = F2(
  	function (callback, _v0) {
  		var parseA = _v0;
  		return function (s0) {
  			var _v1 = parseA(s0);
  			if (_v1.$ === 1) {
  				var p = _v1.a;
  				var x = _v1.b;
  				return A2($elm$parser$Parser$Advanced$Bad, p, x);
  			} else {
  				var p1 = _v1.a;
  				var a = _v1.b;
  				var s1 = _v1.c;
  				var _v2 = callback(a);
  				var parseB = _v2;
  				var _v3 = parseB(s1);
  				if (_v3.$ === 1) {
  					var p2 = _v3.a;
  					var x = _v3.b;
  					return A2($elm$parser$Parser$Advanced$Bad, p1 || p2, x);
  				} else {
  					var p2 = _v3.a;
  					var b = _v3.b;
  					var s2 = _v3.c;
  					return A3($elm$parser$Parser$Advanced$Good, p1 || p2, b, s2);
  				}
  			}
  		};
  	});
  var $elm$parser$Parser$Advanced$Located = F3(
  	function (row, col, context) {
  		return {aO: col, da: context, aX: row};
  	});
  var $elm$parser$Parser$Advanced$changeContext = F2(
  	function (newContext, s) {
  		return {aO: s.aO, da: newContext, c: s.c, ay: s.ay, aX: s.aX, a: s.a};
  	});
  var $elm$parser$Parser$Advanced$inContext = F2(
  	function (context, _v0) {
  		var parse = _v0;
  		return function (s0) {
  			var _v1 = parse(
  				A2(
  					$elm$parser$Parser$Advanced$changeContext,
  					A2(
  						$elm$core$List$cons,
  						A3($elm$parser$Parser$Advanced$Located, s0.aX, s0.aO, context),
  						s0.da),
  					s0));
  			if (!_v1.$) {
  				var p = _v1.a;
  				var a = _v1.b;
  				var s1 = _v1.c;
  				return A3(
  					$elm$parser$Parser$Advanced$Good,
  					p,
  					a,
  					A2($elm$parser$Parser$Advanced$changeContext, s0.da, s1));
  			} else {
  				var step = _v1;
  				return step;
  			}
  		};
  	});
  var $elm$parser$Parser$Advanced$consumeBase = _Parser_consumeBase;
  var $elm$parser$Parser$Advanced$consumeBase16 = _Parser_consumeBase16;
  var $elm$parser$Parser$Advanced$bumpOffset = F2(
  	function (newOffset, s) {
  		return {aO: s.aO + (newOffset - s.ay), da: s.da, c: s.c, ay: newOffset, aX: s.aX, a: s.a};
  	});
  var $elm$parser$Parser$Advanced$chompBase10 = _Parser_chompBase10;
  var $elm$parser$Parser$Advanced$isAsciiCode = _Parser_isAsciiCode;
  var $elm$core$Basics$negate = function (n) {
  	return -n;
  };
  var $elm$parser$Parser$Advanced$consumeExp = F2(
  	function (offset, src) {
  		if (A3($elm$parser$Parser$Advanced$isAsciiCode, 101, offset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 69, offset, src)) {
  			var eOffset = offset + 1;
  			var expOffset = (A3($elm$parser$Parser$Advanced$isAsciiCode, 43, eOffset, src) || A3($elm$parser$Parser$Advanced$isAsciiCode, 45, eOffset, src)) ? (eOffset + 1) : eOffset;
  			var newOffset = A2($elm$parser$Parser$Advanced$chompBase10, expOffset, src);
  			return _Utils_eq(expOffset, newOffset) ? (-newOffset) : newOffset;
  		} else {
  			return offset;
  		}
  	});
  var $elm$parser$Parser$Advanced$consumeDotAndExp = F2(
  	function (offset, src) {
  		return A3($elm$parser$Parser$Advanced$isAsciiCode, 46, offset, src) ? A2(
  			$elm$parser$Parser$Advanced$consumeExp,
  			A2($elm$parser$Parser$Advanced$chompBase10, offset + 1, src),
  			src) : A2($elm$parser$Parser$Advanced$consumeExp, offset, src);
  	});
  var $elm$parser$Parser$Advanced$finalizeInt = F5(
  	function (invalid, handler, startOffset, _v0, s) {
  		var endOffset = _v0.a;
  		var n = _v0.b;
  		if (handler.$ === 1) {
  			var x = handler.a;
  			return A2(
  				$elm$parser$Parser$Advanced$Bad,
  				true,
  				A2($elm$parser$Parser$Advanced$fromState, s, x));
  		} else {
  			var toValue = handler.a;
  			return _Utils_eq(startOffset, endOffset) ? A2(
  				$elm$parser$Parser$Advanced$Bad,
  				_Utils_cmp(s.ay, startOffset) < 0,
  				A2($elm$parser$Parser$Advanced$fromState, s, invalid)) : A3(
  				$elm$parser$Parser$Advanced$Good,
  				true,
  				toValue(n),
  				A2($elm$parser$Parser$Advanced$bumpOffset, endOffset, s));
  		}
  	});
  var $elm$parser$Parser$Advanced$fromInfo = F4(
  	function (row, col, x, context) {
  		return A2(
  			$elm$parser$Parser$Advanced$AddRight,
  			$elm$parser$Parser$Advanced$Empty,
  			A4($elm$parser$Parser$Advanced$DeadEnd, row, col, x, context));
  	});
  var $elm$core$String$toFloat = _String_toFloat;
  var $elm$parser$Parser$Advanced$finalizeFloat = F6(
  	function (invalid, expecting, intSettings, floatSettings, intPair, s) {
  		var intOffset = intPair.a;
  		var floatOffset = A2($elm$parser$Parser$Advanced$consumeDotAndExp, intOffset, s.a);
  		if (floatOffset < 0) {
  			return A2(
  				$elm$parser$Parser$Advanced$Bad,
  				true,
  				A4($elm$parser$Parser$Advanced$fromInfo, s.aX, s.aO - (floatOffset + s.ay), invalid, s.da));
  		} else {
  			if (_Utils_eq(s.ay, floatOffset)) {
  				return A2(
  					$elm$parser$Parser$Advanced$Bad,
  					false,
  					A2($elm$parser$Parser$Advanced$fromState, s, expecting));
  			} else {
  				if (_Utils_eq(intOffset, floatOffset)) {
  					return A5($elm$parser$Parser$Advanced$finalizeInt, invalid, intSettings, s.ay, intPair, s);
  				} else {
  					if (floatSettings.$ === 1) {
  						var x = floatSettings.a;
  						return A2(
  							$elm$parser$Parser$Advanced$Bad,
  							true,
  							A2($elm$parser$Parser$Advanced$fromState, s, invalid));
  					} else {
  						var toValue = floatSettings.a;
  						var _v1 = $elm$core$String$toFloat(
  							A3($elm$core$String$slice, s.ay, floatOffset, s.a));
  						if (_v1.$ === 1) {
  							return A2(
  								$elm$parser$Parser$Advanced$Bad,
  								true,
  								A2($elm$parser$Parser$Advanced$fromState, s, invalid));
  						} else {
  							var n = _v1.a;
  							return A3(
  								$elm$parser$Parser$Advanced$Good,
  								true,
  								toValue(n),
  								A2($elm$parser$Parser$Advanced$bumpOffset, floatOffset, s));
  						}
  					}
  				}
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$number = function (c) {
  	return function (s) {
  		if (A3($elm$parser$Parser$Advanced$isAsciiCode, 48, s.ay, s.a)) {
  			var zeroOffset = s.ay + 1;
  			var baseOffset = zeroOffset + 1;
  			return A3($elm$parser$Parser$Advanced$isAsciiCode, 120, zeroOffset, s.a) ? A5(
  				$elm$parser$Parser$Advanced$finalizeInt,
  				c.dC,
  				c.bV,
  				baseOffset,
  				A2($elm$parser$Parser$Advanced$consumeBase16, baseOffset, s.a),
  				s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 111, zeroOffset, s.a) ? A5(
  				$elm$parser$Parser$Advanced$finalizeInt,
  				c.dC,
  				c.b6,
  				baseOffset,
  				A3($elm$parser$Parser$Advanced$consumeBase, 8, baseOffset, s.a),
  				s) : (A3($elm$parser$Parser$Advanced$isAsciiCode, 98, zeroOffset, s.a) ? A5(
  				$elm$parser$Parser$Advanced$finalizeInt,
  				c.dC,
  				c.bE,
  				baseOffset,
  				A3($elm$parser$Parser$Advanced$consumeBase, 2, baseOffset, s.a),
  				s) : A6(
  				$elm$parser$Parser$Advanced$finalizeFloat,
  				c.dC,
  				c.bd,
  				c.bZ,
  				c.bO,
  				_Utils_Tuple2(zeroOffset, 0),
  				s)));
  		} else {
  			return A6(
  				$elm$parser$Parser$Advanced$finalizeFloat,
  				c.dC,
  				c.bd,
  				c.bZ,
  				c.bO,
  				A3($elm$parser$Parser$Advanced$consumeBase, 10, s.ay, s.a),
  				s);
  		}
  	};
  };
  var $elm$parser$Parser$Advanced$int = F2(
  	function (expecting, invalid) {
  		return $elm$parser$Parser$Advanced$number(
  			{
  				bE: $elm$core$Result$Err(invalid),
  				bd: expecting,
  				bO: $elm$core$Result$Err(invalid),
  				bV: $elm$core$Result$Err(invalid),
  				bZ: $elm$core$Result$Ok($elm$core$Basics$identity),
  				dC: invalid,
  				b6: $elm$core$Result$Err(invalid)
  			});
  	});
  var $elm$parser$Parser$Advanced$keeper = F2(
  	function (parseFunc, parseArg) {
  		return A3($elm$parser$Parser$Advanced$map2, $elm$core$Basics$apL, parseFunc, parseArg);
  	});
  var $elm$parser$Parser$Advanced$map = F2(
  	function (func, _v0) {
  		var parse = _v0;
  		return function (s0) {
  			var _v1 = parse(s0);
  			if (!_v1.$) {
  				var p = _v1.a;
  				var a = _v1.b;
  				var s1 = _v1.c;
  				return A3(
  					$elm$parser$Parser$Advanced$Good,
  					p,
  					func(a),
  					s1);
  			} else {
  				var p = _v1.a;
  				var x = _v1.b;
  				return A2($elm$parser$Parser$Advanced$Bad, p, x);
  			}
  		};
  	});
  var $elm$parser$Parser$Advanced$Append = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $elm$parser$Parser$Advanced$oneOfHelp = F3(
  	function (s0, bag, parsers) {
  		oneOfHelp:
  		while (true) {
  			if (!parsers.b) {
  				return A2($elm$parser$Parser$Advanced$Bad, false, bag);
  			} else {
  				var parse = parsers.a;
  				var remainingParsers = parsers.b;
  				var _v1 = parse(s0);
  				if (!_v1.$) {
  					var step = _v1;
  					return step;
  				} else {
  					var step = _v1;
  					var p = step.a;
  					var x = step.b;
  					if (p) {
  						return step;
  					} else {
  						var $temp$s0 = s0,
  							$temp$bag = A2($elm$parser$Parser$Advanced$Append, bag, x),
  							$temp$parsers = remainingParsers;
  						s0 = $temp$s0;
  						bag = $temp$bag;
  						parsers = $temp$parsers;
  						continue oneOfHelp;
  					}
  				}
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$oneOf = function (parsers) {
  	return function (s) {
  		return A3($elm$parser$Parser$Advanced$oneOfHelp, s, $elm$parser$Parser$Advanced$Empty, parsers);
  	};
  };
  var $elm$parser$Parser$Advanced$problem = function (x) {
  	return function (s) {
  		return A2(
  			$elm$parser$Parser$Advanced$Bad,
  			false,
  			A2($elm$parser$Parser$Advanced$fromState, s, x));
  	};
  };
  var $elm$parser$Parser$Advanced$succeed = function (a) {
  	return function (s) {
  		return A3($elm$parser$Parser$Advanced$Good, false, a, s);
  	};
  };
  var $elm$parser$Parser$Advanced$isSubString = _Parser_isSubString;
  var $elm$core$Basics$not = _Basics_not;
  var $elm$parser$Parser$Advanced$token = function (_v0) {
  	var str = _v0.a;
  	var expecting = _v0.b;
  	var progress = !$elm$core$String$isEmpty(str);
  	return function (s) {
  		var _v1 = A5($elm$parser$Parser$Advanced$isSubString, str, s.ay, s.aX, s.aO, s.a);
  		var newOffset = _v1.a;
  		var newRow = _v1.b;
  		var newCol = _v1.c;
  		return _Utils_eq(newOffset, -1) ? A2(
  			$elm$parser$Parser$Advanced$Bad,
  			false,
  			A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
  			$elm$parser$Parser$Advanced$Good,
  			progress,
  			0,
  			{aO: newCol, da: s.da, c: s.c, ay: newOffset, aX: newRow, a: s.a});
  	};
  };
  var $elm$parser$Parser$Advanced$symbol = $elm$parser$Parser$Advanced$token;
  var $author$project$AsmParser$ExpectingLabel = {$: 14};
  var $author$project$AsmParser$Located = F3(
  	function (from, value, to) {
  		return {be: from, eo: to, F: value};
  	});
  var $elm$parser$Parser$Advanced$getPosition = function (s) {
  	return A3(
  		$elm$parser$Parser$Advanced$Good,
  		false,
  		_Utils_Tuple2(s.aX, s.aO),
  		s);
  };
  var $author$project$AsmParser$located = function (parser) {
  	return A2(
  		$elm$parser$Parser$Advanced$keeper,
  		A2(
  			$elm$parser$Parser$Advanced$keeper,
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				$elm$parser$Parser$Advanced$succeed($author$project$AsmParser$Located),
  				$elm$parser$Parser$Advanced$getPosition),
  			parser),
  		$elm$parser$Parser$Advanced$getPosition);
  };
  var $elm$parser$Parser$Advanced$isSubChar = _Parser_isSubChar;
  var $elm$core$Dict$member = F2(
  	function (key, dict) {
  		var _v0 = A2($elm$core$Dict$get, key, dict);
  		if (!_v0.$) {
  			return true;
  		} else {
  			return false;
  		}
  	});
  var $elm$core$Set$member = F2(
  	function (key, _v0) {
  		var dict = _v0;
  		return A2($elm$core$Dict$member, key, dict);
  	});
  var $elm$parser$Parser$Advanced$varHelp = F7(
  	function (isGood, offset, row, col, src, indent, context) {
  		varHelp:
  		while (true) {
  			var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, src);
  			if (_Utils_eq(newOffset, -1)) {
  				return {aO: col, da: context, c: indent, ay: offset, aX: row, a: src};
  			} else {
  				if (_Utils_eq(newOffset, -2)) {
  					var $temp$isGood = isGood,
  						$temp$offset = offset + 1,
  						$temp$row = row + 1,
  						$temp$col = 1,
  						$temp$src = src,
  						$temp$indent = indent,
  						$temp$context = context;
  					isGood = $temp$isGood;
  					offset = $temp$offset;
  					row = $temp$row;
  					col = $temp$col;
  					src = $temp$src;
  					indent = $temp$indent;
  					context = $temp$context;
  					continue varHelp;
  				} else {
  					var $temp$isGood = isGood,
  						$temp$offset = newOffset,
  						$temp$row = row,
  						$temp$col = col + 1,
  						$temp$src = src,
  						$temp$indent = indent,
  						$temp$context = context;
  					isGood = $temp$isGood;
  					offset = $temp$offset;
  					row = $temp$row;
  					col = $temp$col;
  					src = $temp$src;
  					indent = $temp$indent;
  					context = $temp$context;
  					continue varHelp;
  				}
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$variable = function (i) {
  	return function (s) {
  		var firstOffset = A3($elm$parser$Parser$Advanced$isSubChar, i.bv, s.ay, s.a);
  		if (_Utils_eq(firstOffset, -1)) {
  			return A2(
  				$elm$parser$Parser$Advanced$Bad,
  				false,
  				A2($elm$parser$Parser$Advanced$fromState, s, i.bd));
  		} else {
  			var s1 = _Utils_eq(firstOffset, -2) ? A7($elm$parser$Parser$Advanced$varHelp, i.bj, s.ay + 1, s.aX + 1, 1, s.a, s.c, s.da) : A7($elm$parser$Parser$Advanced$varHelp, i.bj, firstOffset, s.aX, s.aO + 1, s.a, s.c, s.da);
  			var name = A3($elm$core$String$slice, s.ay, s1.ay, s.a);
  			return A2($elm$core$Set$member, name, i.bs) ? A2(
  				$elm$parser$Parser$Advanced$Bad,
  				false,
  				A2($elm$parser$Parser$Advanced$fromState, s, i.bd)) : A3($elm$parser$Parser$Advanced$Good, true, name, s1);
  		}
  	};
  };
  var $author$project$AsmParser$usedLabel = $author$project$AsmParser$located(
  	$elm$parser$Parser$Advanced$variable(
  		{
  			bd: $author$project$AsmParser$ExpectingLabel,
  			bj: function (c) {
  				return ($elm$core$Char$isAlphaNum(c) && (!$elm$core$Char$isLower(c))) || (c === '_');
  			},
  			bs: $elm$core$Set$empty,
  			bv: $elm$core$Char$isUpper
  		}));
  var $author$project$AsmParser$ExpectingVariableName = {$: 16};
  var $author$project$AsmParser$variableName = $author$project$AsmParser$located(
  	$elm$parser$Parser$Advanced$variable(
  		{
  			bd: $author$project$AsmParser$ExpectingVariableName,
  			bj: function (c) {
  				return ($elm$core$Char$isAlphaNum(c) && (!$elm$core$Char$isUpper(c))) || (c === '_');
  			},
  			bs: $elm$core$Set$empty,
  			bv: $elm$core$Char$isLower
  		}));
  var $author$project$AsmParser$aInstruction = A2(
  	$elm$parser$Parser$Advanced$andThen,
  	function (arg) {
  		if (!arg.$) {
  			var number = arg.a;
  			return (_Utils_cmp(
  				number,
  				A2($elm$core$Basics$pow, 2, 31)) > -1) ? $elm$parser$Parser$Advanced$problem(
  				$author$project$AsmParser$NumberTooLarge(number)) : $elm$parser$Parser$Advanced$succeed(
  				$author$project$AsmParser$ParserAInstruction(
  					$author$project$AsmParser$ParserAInstructionNumber(number)));
  		} else {
  			var name = arg.a;
  			return $elm$parser$Parser$Advanced$succeed(
  				$author$project$AsmParser$ParserAInstruction(
  					$author$project$AsmParser$ParserAInstructionLabel(name)));
  		}
  	},
  	A2(
  		$elm$parser$Parser$Advanced$keeper,
  		A2(
  			$elm$parser$Parser$Advanced$ignorer,
  			$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  			$elm$parser$Parser$Advanced$symbol(
  				A2($elm$parser$Parser$Advanced$Token, '@', $author$project$AsmParser$ExpectingAtSign))),
  		A2(
  			$elm$parser$Parser$Advanced$inContext,
  			0,
  			$elm$parser$Parser$Advanced$oneOf(
  				_List_fromArray(
  					[
  						A2(
  						$elm$parser$Parser$Advanced$map,
  						$author$project$AsmParser$ParserAInstructionLabel,
  						$elm$parser$Parser$Advanced$oneOf(
  							_List_fromArray(
  								[$author$project$AsmParser$usedLabel, $author$project$AsmParser$variableName]))),
  						A2(
  						$elm$parser$Parser$Advanced$map,
  						$author$project$AsmParser$ParserAInstructionNumber,
  						A2($elm$parser$Parser$Advanced$int, $author$project$AsmParser$ExpectingInt, $author$project$AsmParser$InvalidNumber))
  					])))));
  var $author$project$AsmParser$CContext = 1;
  var $author$project$AsmParser$ExpectingEqualSign = {$: 1};
  var $author$project$AsmParser$ExpectingSemicolonSign = {$: 2};
  var $author$project$AsmParser$ParserCInstruction = function (a) {
  	return {$: 1, a: a};
  };
  var $author$project$AsmParser$ExpectingComputation = {$: 12};
  var $elm$parser$Parser$Advanced$chompWhileHelp = F5(
  	function (isGood, offset, row, col, s0) {
  		chompWhileHelp:
  		while (true) {
  			var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, offset, s0.a);
  			if (_Utils_eq(newOffset, -1)) {
  				return A3(
  					$elm$parser$Parser$Advanced$Good,
  					_Utils_cmp(s0.ay, offset) < 0,
  					0,
  					{aO: col, da: s0.da, c: s0.c, ay: offset, aX: row, a: s0.a});
  			} else {
  				if (_Utils_eq(newOffset, -2)) {
  					var $temp$isGood = isGood,
  						$temp$offset = offset + 1,
  						$temp$row = row + 1,
  						$temp$col = 1,
  						$temp$s0 = s0;
  					isGood = $temp$isGood;
  					offset = $temp$offset;
  					row = $temp$row;
  					col = $temp$col;
  					s0 = $temp$s0;
  					continue chompWhileHelp;
  				} else {
  					var $temp$isGood = isGood,
  						$temp$offset = newOffset,
  						$temp$row = row,
  						$temp$col = col + 1,
  						$temp$s0 = s0;
  					isGood = $temp$isGood;
  					offset = $temp$offset;
  					row = $temp$row;
  					col = $temp$col;
  					s0 = $temp$s0;
  					continue chompWhileHelp;
  				}
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$chompWhile = function (isGood) {
  	return function (s) {
  		return A5($elm$parser$Parser$Advanced$chompWhileHelp, isGood, s.ay, s.aX, s.aO, s);
  	};
  };
  var $elm$parser$Parser$Advanced$mapChompedString = F2(
  	function (func, _v0) {
  		var parse = _v0;
  		return function (s0) {
  			var _v1 = parse(s0);
  			if (_v1.$ === 1) {
  				var p = _v1.a;
  				var x = _v1.b;
  				return A2($elm$parser$Parser$Advanced$Bad, p, x);
  			} else {
  				var p = _v1.a;
  				var a = _v1.b;
  				var s1 = _v1.c;
  				return A3(
  					$elm$parser$Parser$Advanced$Good,
  					p,
  					A2(
  						func,
  						A3($elm$core$String$slice, s0.ay, s1.ay, s0.a),
  						a),
  					s1);
  			}
  		};
  	});
  var $elm$parser$Parser$Advanced$getChompedString = function (parser) {
  	return A2($elm$parser$Parser$Advanced$mapChompedString, $elm$core$Basics$always, parser);
  };
  var $elm$core$List$any = F2(
  	function (isOkay, list) {
  		any:
  		while (true) {
  			if (!list.b) {
  				return false;
  			} else {
  				var x = list.a;
  				var xs = list.b;
  				if (isOkay(x)) {
  					return true;
  				} else {
  					var $temp$isOkay = isOkay,
  						$temp$list = xs;
  					isOkay = $temp$isOkay;
  					list = $temp$list;
  					continue any;
  				}
  			}
  		}
  	});
  var $elm$core$List$member = F2(
  	function (x, xs) {
  		return A2(
  			$elm$core$List$any,
  			function (a) {
  				return _Utils_eq(a, x);
  			},
  			xs);
  	});
  var $author$project$AsmParser$computation = function () {
  	var comps = _List_fromArray(
  		['0', '1', '-1', 'D', 'A', '!D', '!A', '-D', '-A', 'D+1', 'A+1', 'D-1', 'A-1', 'D+A', 'D-A', 'A-D', 'D&A', 'D|A', 'M', '!M', '-M', 'M+1', 'M-1', 'D+M', 'D-M', 'M-D', 'D&M', 'D|M']);
  	return A2(
  		$elm$parser$Parser$Advanced$andThen,
  		function (str) {
  			return A2($elm$core$List$member, str, comps) ? $elm$parser$Parser$Advanced$succeed(str) : $elm$parser$Parser$Advanced$problem($author$project$AsmParser$ExpectingComputation);
  		},
  		$elm$parser$Parser$Advanced$getChompedString(
  			$elm$parser$Parser$Advanced$chompWhile(
  				function (c) {
  					return (c !== '/') && ((c !== ';') && ((c !== ' ') && (c !== '\n')));
  				})));
  }();
  var $author$project$AsmParser$ExpectingDestinations = function (a) {
  	return {$: 11, a: a};
  };
  var $elm$parser$Parser$Advanced$keyword = function (_v0) {
  	var kwd = _v0.a;
  	var expecting = _v0.b;
  	var progress = !$elm$core$String$isEmpty(kwd);
  	return function (s) {
  		var _v1 = A5($elm$parser$Parser$Advanced$isSubString, kwd, s.ay, s.aX, s.aO, s.a);
  		var newOffset = _v1.a;
  		var newRow = _v1.b;
  		var newCol = _v1.c;
  		return (_Utils_eq(newOffset, -1) || (0 <= A3(
  			$elm$parser$Parser$Advanced$isSubChar,
  			function (c) {
  				return $elm$core$Char$isAlphaNum(c) || (c === '_');
  			},
  			newOffset,
  			s.a))) ? A2(
  			$elm$parser$Parser$Advanced$Bad,
  			false,
  			A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : A3(
  			$elm$parser$Parser$Advanced$Good,
  			progress,
  			0,
  			{aO: newCol, da: s.da, c: s.c, ay: newOffset, aX: newRow, a: s.a});
  	};
  };
  var $author$project$AsmParser$destinations = $elm$parser$Parser$Advanced$oneOf(
  	A2(
  		$elm$core$List$map,
  		function (str) {
  			var dest = {
  				cE: A2($elm$core$String$contains, 'A', str),
  				dd: A2($elm$core$String$contains, 'D', str),
  				dI: A2($elm$core$String$contains, 'M', str)
  			};
  			return A2(
  				$elm$parser$Parser$Advanced$map,
  				function (_v0) {
  					return dest;
  				},
  				$elm$parser$Parser$Advanced$keyword(
  					A2(
  						$elm$parser$Parser$Advanced$Token,
  						str,
  						$author$project$AsmParser$ExpectingDestinations(str))));
  		},
  		_List_fromArray(
  			['AMD', 'AD', 'AM', 'MD', 'M', 'D', 'A'])));
  var $author$project$AsmParser$ExpectingJump = function (a) {
  	return {$: 13, a: a};
  };
  var $author$project$AsmParser$jump = $elm$parser$Parser$Advanced$oneOf(
  	A2(
  		$elm$core$List$map,
  		function (str) {
  			var jmp = function () {
  				switch (str) {
  					case 'JGT':
  						return {dj: false, dp: true, dH: false};
  					case 'JEQ':
  						return {dj: true, dp: false, dH: false};
  					case 'JGE':
  						return {dj: true, dp: true, dH: false};
  					case 'JLT':
  						return {dj: false, dp: false, dH: true};
  					case 'JNE':
  						return {dj: false, dp: true, dH: true};
  					case 'JLE':
  						return {dj: true, dp: false, dH: true};
  					default:
  						return {dj: true, dp: true, dH: true};
  				}
  			}();
  			return A2(
  				$elm$parser$Parser$Advanced$map,
  				function (_v0) {
  					return jmp;
  				},
  				$elm$parser$Parser$Advanced$keyword(
  					A2(
  						$elm$parser$Parser$Advanced$Token,
  						str,
  						$author$project$AsmParser$ExpectingJump(str))));
  		},
  		_List_fromArray(
  			['JGT', 'JEQ', 'JGE', 'JLT', 'JNE', 'JLE', 'JMP'])));
  var $elm$parser$Parser$Advanced$backtrackable = function (_v0) {
  	var parse = _v0;
  	return function (s0) {
  		var _v1 = parse(s0);
  		if (_v1.$ === 1) {
  			var x = _v1.b;
  			return A2($elm$parser$Parser$Advanced$Bad, false, x);
  		} else {
  			var a = _v1.b;
  			var s1 = _v1.c;
  			return A3($elm$parser$Parser$Advanced$Good, false, a, s1);
  		}
  	};
  };
  var $author$project$AsmParser$optional = F2(
  	function (_default, parser) {
  		return $elm$parser$Parser$Advanced$oneOf(
  			_List_fromArray(
  				[
  					$elm$parser$Parser$Advanced$backtrackable(parser),
  					$elm$parser$Parser$Advanced$succeed(_default)
  				]));
  	});
  var $author$project$AsmParser$cInstruction = A2(
  	$elm$parser$Parser$Advanced$inContext,
  	1,
  	A2(
  		$elm$parser$Parser$Advanced$keeper,
  		A2(
  			$elm$parser$Parser$Advanced$keeper,
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				$elm$parser$Parser$Advanced$succeed(
  					F3(
  						function (dest, comp, jmp) {
  							return $author$project$AsmParser$ParserCInstruction(
  								{c8: comp, dg: dest, dE: jmp});
  						})),
  				A2(
  					$author$project$AsmParser$optional,
  					{cE: false, dd: false, dI: false},
  					A2(
  						$elm$parser$Parser$Advanced$keeper,
  						$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  						A2(
  							$elm$parser$Parser$Advanced$ignorer,
  							$author$project$AsmParser$destinations,
  							$elm$parser$Parser$Advanced$symbol(
  								A2($elm$parser$Parser$Advanced$Token, '=', $author$project$AsmParser$ExpectingEqualSign)))))),
  			$author$project$AsmParser$computation),
  		A2(
  			$author$project$AsmParser$optional,
  			{dj: false, dp: false, dH: false},
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				A2(
  					$elm$parser$Parser$Advanced$ignorer,
  					$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  					$elm$parser$Parser$Advanced$symbol(
  						A2($elm$parser$Parser$Advanced$Token, ';', $author$project$AsmParser$ExpectingSemicolonSign))),
  				$author$project$AsmParser$jump))));
  var $elm$parser$Parser$Advanced$getOffset = function (s) {
  	return A3($elm$parser$Parser$Advanced$Good, false, s.ay, s);
  };
  var $author$project$AsmParser$isVariableName = function (name) {
  	var _v0 = $elm$core$String$uncons(name);
  	if (_v0.$ === 1) {
  		return false;
  	} else {
  		var _v1 = _v0.a;
  		var firstChar = _v1.a;
  		return $elm$core$Char$isLower(firstChar);
  	}
  };
  var $author$project$AsmParser$ExpectingLeftParenSign = {$: 3};
  var $author$project$AsmParser$ExpectingRightParenSign = {$: 4};
  var $author$project$AsmParser$LabelContext = 2;
  var $author$project$AsmParser$ParserLabelInstruction = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $author$project$AsmParser$ExpectingCustomLabel = {$: 15};
  var $elm$core$Dict$fromList = function (assocs) {
  	return A3(
  		$elm$core$List$foldl,
  		F2(
  			function (_v0, dict) {
  				var key = _v0.a;
  				var value = _v0.b;
  				return A3($elm$core$Dict$insert, key, value, dict);
  			}),
  		$elm$core$Dict$empty,
  		assocs);
  };
  var $author$project$AsmParser$predefinedSymbolTable = $elm$core$Dict$fromList(
  	_List_fromArray(
  		[
  			_Utils_Tuple2('R0', 0),
  			_Utils_Tuple2('R1', 1),
  			_Utils_Tuple2('R2', 2),
  			_Utils_Tuple2('R3', 3),
  			_Utils_Tuple2('R4', 4),
  			_Utils_Tuple2('R5', 5),
  			_Utils_Tuple2('R6', 6),
  			_Utils_Tuple2('R7', 7),
  			_Utils_Tuple2('R8', 8),
  			_Utils_Tuple2('R9', 9),
  			_Utils_Tuple2('R10', 10),
  			_Utils_Tuple2('R11', 11),
  			_Utils_Tuple2('R12', 12),
  			_Utils_Tuple2('R13', 13),
  			_Utils_Tuple2('R14', 14),
  			_Utils_Tuple2('R15', 15),
  			_Utils_Tuple2(
  			'SCREEN',
  			A2($elm$core$Basics$pow, 2, 16)),
  			_Utils_Tuple2(
  			'KBD',
  			A2($elm$core$Basics$pow, 2, 16) + A2($elm$core$Basics$pow, 2, 15)),
  			_Utils_Tuple2('SP', 0),
  			_Utils_Tuple2('LCL', 1),
  			_Utils_Tuple2('ARG', 2)
  		]));
  var $author$project$AsmParser$predefinedLabels = $elm$core$Set$fromList(
  	$elm$core$Dict$keys($author$project$AsmParser$predefinedSymbolTable));
  var $author$project$AsmParser$declaredLabel = $author$project$AsmParser$located(
  	$elm$parser$Parser$Advanced$variable(
  		{
  			bd: $author$project$AsmParser$ExpectingCustomLabel,
  			bj: function (c) {
  				return ($elm$core$Char$isAlphaNum(c) && (!$elm$core$Char$isLower(c))) || (c === '_');
  			},
  			bs: $author$project$AsmParser$predefinedLabels,
  			bv: $elm$core$Char$isAlpha
  		}));
  var $author$project$AsmParser$labelInstruction = function (instructionIndex) {
  	return A2(
  		$elm$parser$Parser$Advanced$keeper,
  		A2(
  			$elm$parser$Parser$Advanced$ignorer,
  			$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  			$elm$parser$Parser$Advanced$symbol(
  				A2($elm$parser$Parser$Advanced$Token, '(', $author$project$AsmParser$ExpectingLeftParenSign))),
  		A2(
  			$elm$parser$Parser$Advanced$inContext,
  			2,
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				$elm$parser$Parser$Advanced$succeed(
  					function (name) {
  						return A2($author$project$AsmParser$ParserLabelInstruction, name, instructionIndex);
  					}),
  				A2(
  					$elm$parser$Parser$Advanced$ignorer,
  					$author$project$AsmParser$declaredLabel,
  					$elm$parser$Parser$Advanced$symbol(
  						A2($elm$parser$Parser$Advanced$Token, ')', $author$project$AsmParser$ExpectingRightParenSign))))));
  };
  var $elm$parser$Parser$Advanced$loopHelp = F4(
  	function (p, state, callback, s0) {
  		loopHelp:
  		while (true) {
  			var _v0 = callback(state);
  			var parse = _v0;
  			var _v1 = parse(s0);
  			if (!_v1.$) {
  				var p1 = _v1.a;
  				var step = _v1.b;
  				var s1 = _v1.c;
  				if (!step.$) {
  					var newState = step.a;
  					var $temp$p = p || p1,
  						$temp$state = newState,
  						$temp$callback = callback,
  						$temp$s0 = s1;
  					p = $temp$p;
  					state = $temp$state;
  					callback = $temp$callback;
  					s0 = $temp$s0;
  					continue loopHelp;
  				} else {
  					var result = step.a;
  					return A3($elm$parser$Parser$Advanced$Good, p || p1, result, s1);
  				}
  			} else {
  				var p1 = _v1.a;
  				var x = _v1.b;
  				return A2($elm$parser$Parser$Advanced$Bad, p || p1, x);
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$loop = F2(
  	function (state, callback) {
  		return function (s) {
  			return A4($elm$parser$Parser$Advanced$loopHelp, false, state, callback, s);
  		};
  	});
  var $author$project$AsmParser$ExpectingEndOfMultiLineComment = {$: 7};
  var $author$project$AsmParser$ExpectingStartOfLineComment = {$: 5};
  var $author$project$AsmParser$ExpectingStartOfMultiLineComment = {$: 6};
  var $elm$parser$Parser$Advanced$Nestable = 1;
  var $author$project$AsmParser$ifProgress = F2(
  	function (parser, offset) {
  		return A2(
  			$elm$parser$Parser$Advanced$map,
  			function (newOffset) {
  				return _Utils_eq(offset, newOffset) ? $elm$parser$Parser$Advanced$Done(0) : $elm$parser$Parser$Advanced$Loop(newOffset);
  			},
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				A2(
  					$elm$parser$Parser$Advanced$ignorer,
  					$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  					parser),
  				$elm$parser$Parser$Advanced$getOffset));
  	});
  var $elm$parser$Parser$Advanced$findSubString = _Parser_findSubString;
  var $elm$parser$Parser$Advanced$chompUntil = function (_v0) {
  	var str = _v0.a;
  	var expecting = _v0.b;
  	return function (s) {
  		var _v1 = A5($elm$parser$Parser$Advanced$findSubString, str, s.ay, s.aX, s.aO, s.a);
  		var newOffset = _v1.a;
  		var newRow = _v1.b;
  		var newCol = _v1.c;
  		return _Utils_eq(newOffset, -1) ? A2(
  			$elm$parser$Parser$Advanced$Bad,
  			false,
  			A4($elm$parser$Parser$Advanced$fromInfo, newRow, newCol, expecting, s.da)) : A3(
  			$elm$parser$Parser$Advanced$Good,
  			_Utils_cmp(s.ay, newOffset) < 0,
  			0,
  			{aO: newCol, da: s.da, c: s.c, ay: newOffset, aX: newRow, a: s.a});
  	};
  };
  var $elm$parser$Parser$Advanced$chompIf = F2(
  	function (isGood, expecting) {
  		return function (s) {
  			var newOffset = A3($elm$parser$Parser$Advanced$isSubChar, isGood, s.ay, s.a);
  			return _Utils_eq(newOffset, -1) ? A2(
  				$elm$parser$Parser$Advanced$Bad,
  				false,
  				A2($elm$parser$Parser$Advanced$fromState, s, expecting)) : (_Utils_eq(newOffset, -2) ? A3(
  				$elm$parser$Parser$Advanced$Good,
  				true,
  				0,
  				{aO: 1, da: s.da, c: s.c, ay: s.ay + 1, aX: s.aX + 1, a: s.a}) : A3(
  				$elm$parser$Parser$Advanced$Good,
  				true,
  				0,
  				{aO: s.aO + 1, da: s.da, c: s.c, ay: newOffset, aX: s.aX, a: s.a}));
  		};
  	});
  var $elm$parser$Parser$Advanced$isChar = function (_char) {
  	return true;
  };
  var $elm$parser$Parser$Advanced$revAlways = F2(
  	function (_v0, b) {
  		return b;
  	});
  var $elm$parser$Parser$Advanced$skip = F2(
  	function (iParser, kParser) {
  		return A3($elm$parser$Parser$Advanced$map2, $elm$parser$Parser$Advanced$revAlways, iParser, kParser);
  	});
  var $elm$parser$Parser$Advanced$nestableHelp = F5(
  	function (isNotRelevant, open, close, expectingClose, nestLevel) {
  		return A2(
  			$elm$parser$Parser$Advanced$skip,
  			$elm$parser$Parser$Advanced$chompWhile(isNotRelevant),
  			$elm$parser$Parser$Advanced$oneOf(
  				_List_fromArray(
  					[
  						(nestLevel === 1) ? close : A2(
  						$elm$parser$Parser$Advanced$andThen,
  						function (_v0) {
  							return A5($elm$parser$Parser$Advanced$nestableHelp, isNotRelevant, open, close, expectingClose, nestLevel - 1);
  						},
  						close),
  						A2(
  						$elm$parser$Parser$Advanced$andThen,
  						function (_v1) {
  							return A5($elm$parser$Parser$Advanced$nestableHelp, isNotRelevant, open, close, expectingClose, nestLevel + 1);
  						},
  						open),
  						A2(
  						$elm$parser$Parser$Advanced$andThen,
  						function (_v2) {
  							return A5($elm$parser$Parser$Advanced$nestableHelp, isNotRelevant, open, close, expectingClose, nestLevel);
  						},
  						A2($elm$parser$Parser$Advanced$chompIf, $elm$parser$Parser$Advanced$isChar, expectingClose))
  					])));
  	});
  var $elm$parser$Parser$Advanced$nestableComment = F2(
  	function (open, close) {
  		var oStr = open.a;
  		var oX = open.b;
  		var cStr = close.a;
  		var cX = close.b;
  		var _v0 = $elm$core$String$uncons(oStr);
  		if (_v0.$ === 1) {
  			return $elm$parser$Parser$Advanced$problem(oX);
  		} else {
  			var _v1 = _v0.a;
  			var openChar = _v1.a;
  			var _v2 = $elm$core$String$uncons(cStr);
  			if (_v2.$ === 1) {
  				return $elm$parser$Parser$Advanced$problem(cX);
  			} else {
  				var _v3 = _v2.a;
  				var closeChar = _v3.a;
  				var isNotRelevant = function (_char) {
  					return (!_Utils_eq(_char, openChar)) && (!_Utils_eq(_char, closeChar));
  				};
  				var chompOpen = $elm$parser$Parser$Advanced$token(open);
  				return A2(
  					$elm$parser$Parser$Advanced$ignorer,
  					chompOpen,
  					A5(
  						$elm$parser$Parser$Advanced$nestableHelp,
  						isNotRelevant,
  						chompOpen,
  						$elm$parser$Parser$Advanced$token(close),
  						cX,
  						1));
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$multiComment = F3(
  	function (open, close, nestable) {
  		if (!nestable) {
  			return A2(
  				$elm$parser$Parser$Advanced$ignorer,
  				$elm$parser$Parser$Advanced$token(open),
  				$elm$parser$Parser$Advanced$chompUntil(close));
  		} else {
  			return A2($elm$parser$Parser$Advanced$nestableComment, open, close);
  		}
  	});
  var $elm$parser$Parser$Advanced$spaces = $elm$parser$Parser$Advanced$chompWhile(
  	function (c) {
  		return (c === ' ') || ((c === '\n') || (c === '\r'));
  	});
  var $author$project$AsmParser$sps = A2(
  	$elm$parser$Parser$Advanced$loop,
  	0,
  	$author$project$AsmParser$ifProgress(
  		$elm$parser$Parser$Advanced$oneOf(
  			_List_fromArray(
  				[
  					A2(
  					$elm$parser$Parser$Advanced$ignorer,
  					A2(
  						$elm$parser$Parser$Advanced$ignorer,
  						$elm$parser$Parser$Advanced$succeed(0),
  						$elm$parser$Parser$Advanced$symbol(
  							A2($elm$parser$Parser$Advanced$Token, '--', $author$project$AsmParser$ExpectingStartOfLineComment))),
  					$elm$parser$Parser$Advanced$chompWhile(
  						function (c) {
  							return c !== '\n';
  						})),
  					A3(
  					$elm$parser$Parser$Advanced$multiComment,
  					A2($elm$parser$Parser$Advanced$Token, '{-', $author$project$AsmParser$ExpectingStartOfMultiLineComment),
  					A2($elm$parser$Parser$Advanced$Token, '-}', $author$project$AsmParser$ExpectingEndOfMultiLineComment),
  					1),
  					$elm$parser$Parser$Advanced$spaces
  				]))));
  var $author$project$AsmParser$instructions = function () {
  	var initialState = {bk: 0, a0: $elm$core$Dict$empty, bx: 16};
  	return A2(
  		$elm$parser$Parser$Advanced$andThen,
  		function (_v8) {
  			var start = _v8.a;
  			var ins = _v8.b;
  			var end = _v8.c;
  			return _Utils_eq(start, end) ? $elm$parser$Parser$Advanced$problem($author$project$AsmParser$ExpectingInstruction) : $elm$parser$Parser$Advanced$succeed(ins);
  		},
  		A2(
  			$elm$parser$Parser$Advanced$keeper,
  			A2(
  				$elm$parser$Parser$Advanced$keeper,
  				A2(
  					$elm$parser$Parser$Advanced$keeper,
  					$elm$parser$Parser$Advanced$succeed(
  						F3(
  							function (start, _v0, end) {
  								var ins = _v0.a;
  								var state = _v0.b;
  								return _Utils_Tuple3(
  									start,
  									_Utils_Tuple2(ins, state.a0),
  									end);
  							})),
  					$elm$parser$Parser$Advanced$getOffset),
  				A2(
  					$elm$parser$Parser$Advanced$loop,
  					_Utils_Tuple2(_List_Nil, initialState),
  					function (_v1) {
  						var revInstructions = _v1.a;
  						var state = _v1.b;
  						var instructionIndex = state.bk;
  						var variableIndex = state.bx;
  						var symbolTable = state.a0;
  						return $elm$parser$Parser$Advanced$oneOf(
  							_List_fromArray(
  								[
  									A2(
  									$elm$parser$Parser$Advanced$keeper,
  									A2(
  										$elm$parser$Parser$Advanced$ignorer,
  										$elm$parser$Parser$Advanced$succeed(
  											function (instruction) {
  												return $elm$parser$Parser$Advanced$Loop(
  													_Utils_Tuple2(
  														A2($elm$core$List$cons, instruction, revInstructions),
  														{
  															bk: function () {
  																if (instruction.$ === 2) {
  																	return instructionIndex;
  																} else {
  																	return instructionIndex + 1;
  																}
  															}(),
  															a0: function () {
  																switch (instruction.$) {
  																	case 2:
  																		var name = instruction.a;
  																		var number = instruction.b;
  																		return A3($elm$core$Dict$insert, name.F, number, symbolTable);
  																	case 0:
  																		var arg = instruction.a;
  																		if (arg.$ === 1) {
  																			var name = arg.a;
  																			return ($author$project$AsmParser$isVariableName(name.F) && (!A2($elm$core$Dict$member, name.F, symbolTable))) ? A3($elm$core$Dict$insert, name.F, variableIndex, symbolTable) : symbolTable;
  																		} else {
  																			return symbolTable;
  																		}
  																	default:
  																		return symbolTable;
  																}
  															}(),
  															bx: function () {
  																if (!instruction.$) {
  																	var arg = instruction.a;
  																	if (arg.$ === 1) {
  																		var name = arg.a;
  																		return $author$project$AsmParser$isVariableName(name.F) ? (variableIndex + 1) : variableIndex;
  																	} else {
  																		return variableIndex;
  																	}
  																} else {
  																	return variableIndex;
  																}
  															}()
  														}));
  											}),
  										$author$project$AsmParser$sps),
  									A2(
  										$elm$parser$Parser$Advanced$ignorer,
  										$elm$parser$Parser$Advanced$oneOf(
  											_List_fromArray(
  												[
  													$author$project$AsmParser$aInstruction,
  													$author$project$AsmParser$labelInstruction(instructionIndex),
  													$author$project$AsmParser$cInstruction
  												])),
  										$author$project$AsmParser$sps)),
  									A2(
  									$elm$parser$Parser$Advanced$map,
  									function (_v7) {
  										return $elm$parser$Parser$Advanced$Done(
  											_Utils_Tuple2(
  												$elm$core$List$reverse(revInstructions),
  												state));
  									},
  									$elm$parser$Parser$Advanced$succeed(0))
  								]));
  					})),
  			$elm$parser$Parser$Advanced$getOffset));
  }();
  var $elm$core$Result$mapError = F2(
  	function (f, result) {
  		if (!result.$) {
  			var v = result.a;
  			return $elm$core$Result$Ok(v);
  		} else {
  			var e = result.a;
  			return $elm$core$Result$Err(
  				f(e));
  		}
  	});
  var $elm$parser$Parser$Advanced$bagToList = F2(
  	function (bag, list) {
  		bagToList:
  		while (true) {
  			switch (bag.$) {
  				case 0:
  					return list;
  				case 1:
  					var bag1 = bag.a;
  					var x = bag.b;
  					var $temp$bag = bag1,
  						$temp$list = A2($elm$core$List$cons, x, list);
  					bag = $temp$bag;
  					list = $temp$list;
  					continue bagToList;
  				default:
  					var bag1 = bag.a;
  					var bag2 = bag.b;
  					var $temp$bag = bag1,
  						$temp$list = A2($elm$parser$Parser$Advanced$bagToList, bag2, list);
  					bag = $temp$bag;
  					list = $temp$list;
  					continue bagToList;
  			}
  		}
  	});
  var $elm$parser$Parser$Advanced$run = F2(
  	function (_v0, src) {
  		var parse = _v0;
  		var _v1 = parse(
  			{aO: 1, da: _List_Nil, c: 1, ay: 0, aX: 1, a: src});
  		if (!_v1.$) {
  			var value = _v1.b;
  			return $elm$core$Result$Ok(value);
  		} else {
  			var bag = _v1.b;
  			return $elm$core$Result$Err(
  				A2($elm$parser$Parser$Advanced$bagToList, bag, _List_Nil));
  		}
  	});
  var $elm$core$Tuple$second = function (_v0) {
  	var y = _v0.b;
  	return y;
  };
  var $pzp1997$assoc_list$AssocList$keys = function (_v0) {
  	var alist = _v0;
  	return A2($elm$core$List$map, $elm$core$Tuple$first, alist);
  };
  var $Gizra$elm_all_set$EverySet$toList = function (_v0) {
  	var d = _v0;
  	return $pzp1997$assoc_list$AssocList$keys(d);
  };
  var $elm$core$Dict$foldl = F3(
  	function (func, acc, dict) {
  		foldl:
  		while (true) {
  			if (dict.$ === -2) {
  				return acc;
  			} else {
  				var key = dict.b;
  				var value = dict.c;
  				var left = dict.d;
  				var right = dict.e;
  				var $temp$func = func,
  					$temp$acc = A3(
  					func,
  					key,
  					value,
  					A3($elm$core$Dict$foldl, func, acc, left)),
  					$temp$dict = right;
  				func = $temp$func;
  				acc = $temp$acc;
  				dict = $temp$dict;
  				continue foldl;
  			}
  		}
  	});
  var $elm$core$Dict$union = F2(
  	function (t1, t2) {
  		return A3($elm$core$Dict$foldl, $elm$core$Dict$insert, t2, t1);
  	});
  var $elm$core$Set$union = F2(
  	function (_v0, _v1) {
  		var dict1 = _v0;
  		var dict2 = _v1;
  		return A2($elm$core$Dict$union, dict1, dict2);
  	});
  var $author$project$AsmParser$parse = function (src) {
  	return A2(
  		$elm$core$Result$andThen,
  		function (_v0) {
  			var ast = _v0.a;
  			var declaredSymbolTable = _v0.b;
  			var symbolTable = A2($elm$core$Dict$union, declaredSymbolTable, $author$project$AsmParser$predefinedSymbolTable);
  			var declaredSymbols = A2(
  				$elm$core$Set$union,
  				$author$project$AsmParser$predefinedLabels,
  				$elm$core$Set$fromList(
  					$elm$core$Dict$keys(declaredSymbolTable)));
  			var undefinedSymbols = A3(
  				$elm$core$List$foldl,
  				F2(
  					function (instruction, names) {
  						if (!instruction.$) {
  							var arg = instruction.a;
  							if (arg.$ === 1) {
  								var name = arg.a;
  								return A2($elm$core$Set$member, name.F, declaredSymbols) ? names : A2($elm$core$List$cons, name, names);
  							} else {
  								return names;
  							}
  						} else {
  							return names;
  						}
  					}),
  				_List_Nil,
  				ast);
  			if (!undefinedSymbols.b) {
  				var substitutedAst = $elm$core$List$reverse(
  					A3(
  						$elm$core$List$foldl,
  						F2(
  							function (instruction, nextAst) {
  								switch (instruction.$) {
  									case 0:
  										var arg = instruction.a;
  										if (arg.$ === 1) {
  											var name = arg.a;
  											var _v4 = A2($elm$core$Dict$get, name.F, symbolTable);
  											if (_v4.$ === 1) {
  												return nextAst;
  											} else {
  												var number = _v4.a;
  												return A2(
  													$elm$core$List$cons,
  													$author$project$AsmParser$AInstruction(number),
  													nextAst);
  											}
  										} else {
  											var number = arg.a;
  											return A2(
  												$elm$core$List$cons,
  												$author$project$AsmParser$AInstruction(number),
  												nextAst);
  										}
  									case 1:
  										var record = instruction.a;
  										return A2(
  											$elm$core$List$cons,
  											$author$project$AsmParser$CInstruction(record),
  											nextAst);
  									default:
  										return nextAst;
  								}
  							}),
  						_List_Nil,
  						ast));
  				return $elm$core$Result$Ok(substitutedAst);
  			} else {
  				return $elm$core$Result$Err(
  					A2(
  						$elm$core$List$map,
  						function (symbol) {
  							return {
  								aO: symbol.be.b,
  								bJ: _List_Nil,
  								bq: $author$project$AsmParser$UndefinedSymbol(symbol.F),
  								aX: symbol.be.a
  							};
  						},
  						undefinedSymbols));
  			}
  		},
  		A2(
  			$elm$core$Result$mapError,
  			function (deadEnds) {
  				return $elm$core$List$reverse(
  					$Gizra$elm_all_set$EverySet$toList(
  						$Gizra$elm_all_set$EverySet$fromList(deadEnds)));
  			},
  			A2(
  				$elm$parser$Parser$Advanced$run,
  				A2(
  					$elm$parser$Parser$Advanced$keeper,
  					$elm$parser$Parser$Advanced$succeed($elm$core$Basics$identity),
  					A2(
  						$elm$parser$Parser$Advanced$ignorer,
  						$author$project$AsmParser$instructions,
  						$elm$parser$Parser$Advanced$end($author$project$AsmParser$ExpectingEOF))),
  				src)));
  };
  var $elm_community$list_extra$List$Extra$groupWhile = F2(
  	function (isSameGroup, items) {
  		return A3(
  			$elm$core$List$foldr,
  			F2(
  				function (x, acc) {
  					if (!acc.b) {
  						return _List_fromArray(
  							[
  								_Utils_Tuple2(x, _List_Nil)
  							]);
  					} else {
  						var _v1 = acc.a;
  						var y = _v1.a;
  						var restOfGroup = _v1.b;
  						var groups = acc.b;
  						return A2(isSameGroup, x, y) ? A2(
  							$elm$core$List$cons,
  							_Utils_Tuple2(
  								x,
  								A2($elm$core$List$cons, y, restOfGroup)),
  							groups) : A2(
  							$elm$core$List$cons,
  							_Utils_Tuple2(x, _List_Nil),
  							acc);
  					}
  				}),
  			_List_Nil,
  			items);
  	});
  var $elm$core$Basics$composeR = F3(
  	function (f, g, x) {
  		return g(
  			f(x));
  	});
  var $author$project$AsmParser$showProblem = function (p) {
  	switch (p.$) {
  		case 0:
  			return 'a \'@\'';
  		case 1:
  			return 'a \'=\'';
  		case 2:
  			return 'a \';\'';
  		case 3:
  			return 'a \'(\'';
  		case 4:
  			return 'a \')\'';
  		case 8:
  			return 'the end of program';
  		case 9:
  			return 'an instruction';
  		case 10:
  			return 'an integer';
  		case 11:
  			var str = p.a;
  			return str;
  		case 12:
  			return 'a computation like \'D+A\' and \'-1\'';
  		case 13:
  			var str = p.a;
  			return str;
  		case 5:
  			return 'the start of a single-line comment \'--\'';
  		case 6:
  			return 'the start of a multi-line comment \'{-\'';
  		case 7:
  			return 'the end of a multi-line comment \'-}\'';
  		case 14:
  			return 'a label in all caps like `R0`';
  		case 15:
  			return 'a custom label in all caps like `LOOP_0`';
  		case 16:
  			return 'a variable name in all lowercase like `my_variable_0`';
  		case 17:
  			return 'a valid decimal integer';
  		case 18:
  			return 'an integer less than 2147483648 (2^31).';
  		default:
  			return 'a defined symbol';
  	}
  };
  var $author$project$AsmParser$showProblemContext = function (context) {
  	switch (context) {
  		case 0:
  			return 'A instruction';
  		case 1:
  			return 'C instruction';
  		default:
  			return 'label declaration';
  	}
  };
  var $author$project$AsmParser$showProblemContextStack = function (contexts) {
  	return A2(
  		$elm$core$String$join,
  		' of the ',
  		A2(
  			$elm$core$List$map,
  			A2(
  				$elm$core$Basics$composeR,
  				function ($) {
  					return $.da;
  				},
  				$author$project$AsmParser$showProblemContext),
  			contexts));
  };
  var $elm$core$List$drop = F2(
  	function (n, list) {
  		drop:
  		while (true) {
  			if (n <= 0) {
  				return list;
  			} else {
  				if (!list.b) {
  					return list;
  				} else {
  					var x = list.a;
  					var xs = list.b;
  					var $temp$n = n - 1,
  						$temp$list = xs;
  					n = $temp$n;
  					list = $temp$list;
  					continue drop;
  				}
  			}
  		}
  	});
  var $elm$core$List$head = function (list) {
  	if (list.b) {
  		var x = list.a;
  		var xs = list.b;
  		return $elm$core$Maybe$Just(x);
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $elm_community$list_extra$List$Extra$getAt = F2(
  	function (idx, xs) {
  		return (idx < 0) ? $elm$core$Maybe$Nothing : $elm$core$List$head(
  			A2($elm$core$List$drop, idx, xs));
  	});
  var $elm$core$Maybe$withDefault = F2(
  	function (_default, maybe) {
  		if (!maybe.$) {
  			var value = maybe.a;
  			return value;
  		} else {
  			return _default;
  		}
  	});
  var $author$project$AsmParser$getLine = F2(
  	function (row, src) {
  		return A2(
  			$elm$core$Maybe$withDefault,
  			'CAN\'T GET LINE AT ROW ' + $elm$core$String$fromInt(row),
  			A2(
  				$elm_community$list_extra$List$Extra$getAt,
  				row - 1,
  				A2($elm$core$String$split, '\n', src)));
  	});
  var $elm$core$String$fromList = _String_fromList;
  var $elm$core$String$foldr = _String_foldr;
  var $elm$core$String$toList = function (string) {
  	return A3($elm$core$String$foldr, $elm$core$List$cons, _List_Nil, string);
  };
  var $author$project$AsmParser$toUnderlineChar = F3(
  	function (minCol, maxCol, col) {
  		return ((_Utils_cmp(minCol, col) < 1) && (_Utils_cmp(col, maxCol) < 0)) ? '^' : ' ';
  	});
  var $author$project$AsmParser$makeUnderline = F3(
  	function (row, minCol, maxCol) {
  		return $elm$core$String$fromList(
  			A2(
  				$elm$core$List$indexedMap,
  				F2(
  					function (i, _v0) {
  						return A3($author$project$AsmParser$toUnderlineChar, minCol, maxCol, i);
  					}),
  				$elm$core$String$toList(row)));
  	});
  var $elm$core$String$trimLeft = _String_trimLeft;
  var $author$project$AsmParser$showProblemLocation = F4(
  	function (customLineNumber, row, col, src) {
  		var rawLine = A2($author$project$AsmParser$getLine, row, src);
  		var lineNumber = function () {
  			if (customLineNumber.$ === 1) {
  				return row;
  			} else {
  				var number = customLineNumber.a;
  				return number;
  			}
  		}();
  		var line = $elm$core$String$fromInt(lineNumber) + ('| ' + $elm$core$String$trimLeft(rawLine));
  		var offset = ($elm$core$String$length(line) - $elm$core$String$length(rawLine)) - 1;
  		var offsettedCol = offset + col;
  		var underline = A3($author$project$AsmParser$makeUnderline, line, offsettedCol, offsettedCol + 1);
  		return line + ('\n' + underline);
  	});
  var $author$project$AsmParser$showDeadEndsHelper = F3(
  	function (lineNumber, src, _v0) {
  		var first = _v0.a;
  		var rests = _v0.b;
  		var location = A4($author$project$AsmParser$showProblemLocation, lineNumber, first.aX, first.aO, src);
  		var context = $author$project$AsmParser$showProblemContextStack(first.bJ);
  		return location + ('\n' + (function () {
  			var _v1 = first.bq;
  			switch (_v1.$) {
  				case 17:
  					return 'I found an invalid number. I\'m expecting a decimal integer';
  				case 18:
  					var number = _v1.a;
  					return 'I found a number `' + ($elm$core$String$fromInt(number) + '` that\'s too large. All numbers should be less than 2147483648 (2^31)');
  				case 19:
  					var symbol = _v1.a;
  					return 'I found an undefined symbol `' + (symbol + ('`. You should declare it as a label somewhere like so: `(' + (symbol + ')`')));
  				default:
  					var problemStrs = A2(
  						$elm$core$List$map,
  						A2(
  							$elm$core$Basics$composeR,
  							function ($) {
  								return $.bq;
  							},
  							$author$project$AsmParser$showProblem),
  						$elm$core$List$reverse(
  							A2($elm$core$List$cons, first, rests)));
  					return 'I\'m expecting ' + A2($elm$core$String$join, ' or ', problemStrs);
  			}
  		}() + (($elm$core$String$isEmpty(context) ? '' : (' in the ' + context)) + '.')));
  	});
  var $author$project$AsmParser$showDeadEnds = F3(
  	function (lineNumber, src, deadEnds) {
  		var deadEndGroups = A2(
  			$elm_community$list_extra$List$Extra$groupWhile,
  			F2(
  				function (d1, d2) {
  					return _Utils_eq(d1.aX, d2.aX) && _Utils_eq(d1.aO, d2.aO);
  				}),
  			deadEnds);
  		return A2(
  			$elm$core$String$join,
  			'\n',
  			A2(
  				$elm$core$List$map,
  				A2($author$project$AsmParser$showDeadEndsHelper, lineNumber, src),
  				deadEndGroups));
  	});
  var $author$project$Assembler$parseProgram = function (program) {
  	var _v0 = $author$project$AsmParser$parse(program);
  	if (_v0.$ === 1) {
  		var deadEnds = _v0.a;
  		if (!deadEnds.b) {
  			return $elm$core$Result$Err(
  				_Utils_Tuple2(
  					_Utils_Tuple2(0, 0),
  					''));
  		} else {
  			var firstDeadEnd = deadEnds.a;
  			return $elm$core$Result$Err(
  				_Utils_Tuple2(
  					_Utils_Tuple2(firstDeadEnd.aX, firstDeadEnd.aO),
  					A3($author$project$AsmParser$showDeadEnds, $elm$core$Maybe$Nothing, program, deadEnds)));
  		}
  	} else {
  		var ast = _v0.a;
  		return $elm$core$Result$Ok(ast);
  	}
  };
  var $elm$json$Json$Encode$int = _Json_wrap;
  var $elm$json$Json$Encode$list = F2(
  	function (func, entries) {
  		return _Json_wrap(
  			A3(
  				$elm$core$List$foldl,
  				_Json_addEntry(func),
  				_Json_emptyArray(0),
  				entries));
  	});
  var $elm$json$Json$Encode$string = _Json_wrap;
  var $author$project$CpuEmulator$showAssemblerErrorPort = _Platform_outgoingPort(
  	'showAssemblerErrorPort',
  	function ($) {
  		var a = $.a;
  		var b = $.b;
  		return A2(
  			$elm$json$Json$Encode$list,
  			$elm$core$Basics$identity,
  			_List_fromArray(
  				[
  					function ($) {
  					var a = $.a;
  					var b = $.b;
  					return A2(
  						$elm$json$Json$Encode$list,
  						$elm$core$Basics$identity,
  						_List_fromArray(
  							[
  								$elm$json$Json$Encode$int(a),
  								$elm$json$Json$Encode$int(b)
  							]));
  				}(a),
  					$elm$json$Json$Encode$string(b)
  				]));
  	});
  var $author$project$CpuEmulator$editProgram = F2(
  	function (newProgram, model) {
  		var _v0 = $author$project$Assembler$parseProgram(newProgram);
  		if (!_v0.$) {
  			return _Utils_Tuple2(
  				_Utils_update(
  					model,
  					{aA: newProgram}),
  				$author$project$CpuEmulator$clearAssemblerErrorPort(0));
  		} else {
  			var error = _v0.a;
  			return _Utils_Tuple2(
  				_Utils_update(
  					model,
  					{
  						a9: $elm$core$Maybe$Just(error.b),
  						aA: newProgram
  					}),
  				$author$project$CpuEmulator$showAssemblerErrorPort(error));
  		}
  	});
  var $author$project$CpuEmulator$storeToMemory = F3(
  	function (address, value, memory) {
  		return A3($elm$core$Array$set, address, value, memory);
  	});
  var $author$project$CpuEmulator$editRam = F3(
  	function (index, newValue, model) {
  		var oldComputer = model.d;
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{
  					d: _Utils_update(
  						oldComputer,
  						{
  							O: A3(
  								$author$project$CpuEmulator$storeToMemory,
  								index,
  								A2(
  									$elm$core$Maybe$withDefault,
  									0,
  									$elm$core$String$toInt(newValue)),
  								oldComputer.O)
  						})
  				}),
  			$elm$core$Platform$Cmd$none);
  	});
  var $author$project$CpuEmulator$scrollIntoViewPort = _Platform_outgoingPort('scrollIntoViewPort', $elm$json$Json$Encode$string);
  var $author$project$CpuEmulator$resetComputer = function (model) {
  	var oldComputer = model.d;
  	return _Utils_Tuple2(
  		_Utils_update(
  			model,
  			{
  				d: _Utils_update(
  					oldComputer,
  					{l: 0}),
  				V: false
  			}),
  		$author$project$CpuEmulator$scrollIntoViewPort('instruction0'));
  };
  var $author$project$CpuEmulator$NoOp = {$: 18};
  var $elm$core$Task$onError = _Scheduler_onError;
  var $elm$core$Task$attempt = F2(
  	function (resultToMessage, task) {
  		return $elm$core$Task$command(
  			A2(
  				$elm$core$Task$onError,
  				A2(
  					$elm$core$Basics$composeL,
  					A2($elm$core$Basics$composeL, $elm$core$Task$succeed, resultToMessage),
  					$elm$core$Result$Err),
  				A2(
  					$elm$core$Task$andThen,
  					A2(
  						$elm$core$Basics$composeL,
  						A2($elm$core$Basics$composeL, $elm$core$Task$succeed, resultToMessage),
  						$elm$core$Result$Ok),
  					task)));
  	});
  var $elm$browser$Browser$Dom$focus = _Browser_call('focus');
  var $author$project$CpuEmulator$startEditingInstruction = F2(
  	function (index, model) {
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{
  					av: $elm$core$Maybe$Just(index)
  				}),
  			A2(
  				$elm$core$Task$attempt,
  				function (_v0) {
  					return $author$project$CpuEmulator$NoOp;
  				},
  				$elm$browser$Browser$Dom$focus(
  					'instruction' + $elm$core$String$fromInt(index))));
  	});
  var $author$project$CpuEmulator$showProgramEditorPort = _Platform_outgoingPort(
  	'showProgramEditorPort',
  	function ($) {
  		return $elm$json$Json$Encode$null;
  	});
  var $author$project$CpuEmulator$startEditingProgram = function (model) {
  	return _Utils_Tuple2(
  		_Utils_update(
  			model,
  			{ai: true}),
  		$author$project$CpuEmulator$showProgramEditorPort(0));
  };
  var $author$project$CpuEmulator$startEditingRam = F2(
  	function (index, model) {
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{
  					aw: $elm$core$Maybe$Just(index)
  				}),
  			A2(
  				$elm$core$Task$attempt,
  				function (_v0) {
  					return $author$project$CpuEmulator$NoOp;
  				},
  				$elm$browser$Browser$Dom$focus(
  					'ram' + $elm$core$String$fromInt(index))));
  	});
  var $author$project$CpuEmulator$startRunningComputer = function (model) {
  	return _Utils_Tuple2(
  		_Utils_update(
  			model,
  			{w: false, V: true}),
  		$elm$core$Platform$Cmd$none);
  };
  var $author$project$CpuEmulator$dropBits = F2(
  	function (dropAmount, bits) {
  		return (bits << dropAmount) >>> dropAmount;
  	});
  var $elm$core$Array$getHelp = F3(
  	function (shift, index, tree) {
  		getHelp:
  		while (true) {
  			var pos = $elm$core$Array$bitMask & (index >>> shift);
  			var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
  			if (!_v0.$) {
  				var subTree = _v0.a;
  				var $temp$shift = shift - $elm$core$Array$shiftStep,
  					$temp$index = index,
  					$temp$tree = subTree;
  				shift = $temp$shift;
  				index = $temp$index;
  				tree = $temp$tree;
  				continue getHelp;
  			} else {
  				var values = _v0.a;
  				return A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, values);
  			}
  		}
  	});
  var $elm$core$Array$get = F2(
  	function (index, _v0) {
  		var len = _v0.a;
  		var startShift = _v0.b;
  		var tree = _v0.c;
  		var tail = _v0.d;
  		return ((index < 0) || (_Utils_cmp(index, len) > -1)) ? $elm$core$Maybe$Nothing : ((_Utils_cmp(
  			index,
  			$elm$core$Array$tailIndex(len)) > -1) ? $elm$core$Maybe$Just(
  			A2($elm$core$Elm$JsArray$unsafeGet, $elm$core$Array$bitMask & index, tail)) : $elm$core$Maybe$Just(
  			A3($elm$core$Array$getHelp, startShift, index, tree)));
  	});
  var $elm$core$Bitwise$shiftRightBy = _Bitwise_shiftRightBy;
  var $author$project$CpuEmulator$getBit = F2(
  	function (index, bits) {
  		return function (bit) {
  			return bit === 1;
  		}(1 & (bits >> index));
  	});
  var $author$project$CpuEmulator$fetchFromMemory = F2(
  	function (address, memory) {
  		return A2(
  			$elm$core$Maybe$withDefault,
  			0,
  			A2($elm$core$Array$get, address, memory));
  	});
  var $author$project$CpuEmulator$stepAInstruction = F2(
  	function (number, computer) {
  		return _Utils_update(
  			computer,
  			{
  				r: number,
  				X: A2($author$project$CpuEmulator$fetchFromMemory, number, computer.O),
  				l: computer.l + 1
  			});
  	});
  var $elm$core$Bitwise$complement = _Bitwise_complement;
  var $elm$core$Bitwise$or = _Bitwise_or;
  var $author$project$CpuEmulator$compute = F2(
  	function (computationBits, computer) {
  		var m = computer.X;
  		var d = computer.ag;
  		var a = computer.r;
  		switch (computationBits) {
  			case 42:
  				return 0;
  			case 63:
  				return 1;
  			case 58:
  				return -1;
  			case 12:
  				return d;
  			case 48:
  				return a;
  			case 13:
  				return ~d;
  			case 49:
  				return ~a;
  			case 15:
  				return -d;
  			case 51:
  				return -a;
  			case 31:
  				return d + 1;
  			case 55:
  				return a + 1;
  			case 14:
  				return d - 1;
  			case 50:
  				return a - 1;
  			case 2:
  				return d + a;
  			case 19:
  				return d - a;
  			case 7:
  				return a - d;
  			case 0:
  				return d & a;
  			case 21:
  				return d | a;
  			case 112:
  				return m;
  			case 113:
  				return ~m;
  			case 115:
  				return -m;
  			case 119:
  				return m + 1;
  			case 114:
  				return m - 1;
  			case 66:
  				return d + m;
  			case 83:
  				return d - m;
  			case 71:
  				return m - d;
  			case 64:
  				return d & m;
  			case 85:
  				return d | m;
  			default:
  				return 0;
  		}
  	});
  var $author$project$CpuEmulator$moveProgramCounter = F3(
  	function (jumpBits, computationResult, computer) {
  		var zr = !computationResult;
  		var ng = computationResult < 0;
  		var lt = A2($author$project$CpuEmulator$getBit, 2, jumpBits);
  		var gt = A2($author$project$CpuEmulator$getBit, 0, jumpBits);
  		var eq = A2($author$project$CpuEmulator$getBit, 1, jumpBits);
  		var jump = (lt ? ng : false) || ((eq ? zr : false) || (gt ? ((!ng) && (!zr)) : false));
  		return jump ? _Utils_update(
  			computer,
  			{l: computer.r}) : _Utils_update(
  			computer,
  			{l: computer.l + 1});
  	});
  var $elm$core$Basics$modBy = _Basics_modBy;
  var $author$project$CpuEmulator$storeComputationResult = F3(
  	function (destinationsBits, result, computer) {
  		var storeToMRegister = A2($author$project$CpuEmulator$getBit, 0, destinationsBits);
  		var storeToDRegister = A2($author$project$CpuEmulator$getBit, 1, destinationsBits);
  		var storeToARegister = A2($author$project$CpuEmulator$getBit, 2, destinationsBits);
  		var newMRegister = storeToMRegister ? result : computer.X;
  		var newDRegister = storeToDRegister ? result : computer.ag;
  		var newARegister = storeToARegister ? result : computer.r;
  		return _Utils_update(
  			computer,
  			{
  				r: newARegister,
  				ag: newDRegister,
  				X: newMRegister,
  				O: A3($author$project$CpuEmulator$storeToMemory, computer.r, newMRegister, computer.O),
  				Q: function () {
  					if (storeToMRegister) {
  						if ((_Utils_cmp(
  							A2($elm$core$Basics$pow, 2, 16),
  							computer.r) < 1) && (_Utils_cmp(
  							computer.r,
  							A2($elm$core$Basics$pow, 2, 16) + A2($elm$core$Basics$pow, 2, 15)) < 1)) {
  							var width = (512 / 4) | 0;
  							var offset = computer.r - A2($elm$core$Basics$pow, 2, 16);
  							var x = A2($elm$core$Basics$modBy, width, offset);
  							var y = (offset / width) | 0;
  							return A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									_Utils_Tuple2(x, y),
  									newMRegister),
  								computer.Q);
  						} else {
  							return computer.Q;
  						}
  					} else {
  						return computer.Q;
  					}
  				}()
  			});
  	});
  var $author$project$CpuEmulator$stepCInstruction = F2(
  	function (instruction, computer) {
  		var jumpBits = 7 & instruction;
  		var destinationsBits = (56 & instruction) >>> 3;
  		var computationBits = instruction >>> 6;
  		var computationResult = A2($author$project$CpuEmulator$compute, computationBits, computer);
  		return A3(
  			$author$project$CpuEmulator$moveProgramCounter,
  			jumpBits,
  			computationResult,
  			A3($author$project$CpuEmulator$storeComputationResult, destinationsBits, computationResult, computer));
  	});
  var $author$project$CpuEmulator$step = function (computer) {
  	var _v0 = A2($elm$core$Array$get, computer.l, computer.am);
  	if (!_v0.$) {
  		var instruction = _v0.a;
  		var opCode = A2($author$project$CpuEmulator$getBit, 31, instruction);
  		var computer1 = function () {
  			var _v1 = computer.K;
  			if (_v1.$ === 1) {
  				return computer;
  			} else {
  				return _Utils_update(
  					computer,
  					{K: $elm$core$Maybe$Nothing});
  			}
  		}();
  		return (!opCode) ? A2($author$project$CpuEmulator$stepAInstruction, instruction, computer1) : A2(
  			$author$project$CpuEmulator$stepCInstruction,
  			A2($author$project$CpuEmulator$dropBits, 19, instruction),
  			computer1);
  	} else {
  		return computer;
  	}
  };
  var $author$project$CpuEmulator$updatePixelsPort = _Platform_outgoingPort(
  	'updatePixelsPort',
  	$elm$json$Json$Encode$list(
  		function ($) {
  			var a = $.a;
  			var b = $.b;
  			return A2(
  				$elm$json$Json$Encode$list,
  				$elm$core$Basics$identity,
  				_List_fromArray(
  					[
  						function ($) {
  						var a = $.a;
  						var b = $.b;
  						return A2(
  							$elm$json$Json$Encode$list,
  							$elm$core$Basics$identity,
  							_List_fromArray(
  								[
  									$elm$json$Json$Encode$int(a),
  									$elm$json$Json$Encode$int(b)
  								]));
  					}(a),
  						$elm$json$Json$Encode$int(b)
  					]));
  		}));
  var $author$project$CpuEmulator$stepComputer = function (model) {
  	var instructionId = 'instruction' + $elm$core$String$fromInt(model.d.l);
  	return _Utils_Tuple2(
  		_Utils_update(
  			model,
  			{
  				d: $author$project$CpuEmulator$step(model.d)
  			}),
  		$elm$core$Platform$Cmd$batch(
  			_List_fromArray(
  				[
  					model.w ? $author$project$CpuEmulator$scrollIntoViewPort(instructionId) : $elm$core$Platform$Cmd$none,
  					function () {
  					var _v0 = model.d.Q;
  					if (!_v0.b) {
  						return $elm$core$Platform$Cmd$none;
  					} else {
  						var pixels = _v0;
  						return $author$project$CpuEmulator$updatePixelsPort(
  							$elm$core$List$reverse(pixels));
  					}
  				}()
  				])));
  };
  var $elm$core$Basics$min = F2(
  	function (x, y) {
  		return (_Utils_cmp(x, y) < 0) ? x : y;
  	});
  var $author$project$CpuEmulator$stepComputerOneFrameHelper = F2(
  	function (numberOfInstructionsLeft, computer) {
  		stepComputerOneFrameHelper:
  		while (true) {
  			if (numberOfInstructionsLeft > 0) {
  				var $temp$numberOfInstructionsLeft = numberOfInstructionsLeft - 1,
  					$temp$computer = $author$project$CpuEmulator$step(computer);
  				numberOfInstructionsLeft = $temp$numberOfInstructionsLeft;
  				computer = $temp$computer;
  				continue stepComputerOneFrameHelper;
  			} else {
  				return computer;
  			}
  		}
  	});
  var $author$project$CpuEmulator$stepComputerOneFrame = F2(
  	function (time, model) {
  		var timeToRun = A2($elm$core$Basics$min, time, 1000);
  		var steps = $elm$core$Basics$ceiling((((timeToRun / 1000) * 2.2) * 256) * 1024);
  		var nextComputer = A2($author$project$CpuEmulator$stepComputerOneFrameHelper, steps, model.d);
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{d: nextComputer}),
  			$elm$core$Platform$Cmd$batch(
  				_List_fromArray(
  					[
  						function () {
  						var _v0 = nextComputer.Q;
  						if (!_v0.b) {
  							return $elm$core$Platform$Cmd$none;
  						} else {
  							var pixels = _v0;
  							return $author$project$CpuEmulator$updatePixelsPort(pixels);
  						}
  					}()
  					])));
  	});
  var $author$project$AsmEmitter$emitComputation = function (computation) {
  	switch (computation) {
  		case '0':
  			return '0101010';
  		case '1':
  			return '0111111';
  		case '-1':
  			return '0111010';
  		case 'D':
  			return '0001100';
  		case 'A':
  			return '0110000';
  		case '!D':
  			return '0001101';
  		case '!A':
  			return '0110001';
  		case '-D':
  			return '0001111';
  		case '-A':
  			return '0110011';
  		case 'D+1':
  			return '0011111';
  		case 'A+1':
  			return '0110111';
  		case 'D-1':
  			return '0001110';
  		case 'A-1':
  			return '0110010';
  		case 'D+A':
  			return '0000010';
  		case 'D-A':
  			return '0010011';
  		case 'A-D':
  			return '0000111';
  		case 'D&A':
  			return '0000000';
  		case 'D|A':
  			return '0010101';
  		case 'M':
  			return '1110000';
  		case '!M':
  			return '1110001';
  		case '-M':
  			return '1110011';
  		case 'M+1':
  			return '1110111';
  		case 'M-1':
  			return '1110010';
  		case 'D+M':
  			return '1000010';
  		case 'D-M':
  			return '1010011';
  		case 'M-D':
  			return '1000111';
  		case 'D&M':
  			return '1000000';
  		case 'D|M':
  			return '1010101';
  		default:
  			return 'INVALID COMPUTATION';
  	}
  };
  var $author$project$AsmEmitter$boolToString = function (b) {
  	return b ? '1' : '0';
  };
  var $author$project$AsmEmitter$emitDestinations = function (destinations) {
  	return _Utils_ap(
  		$author$project$AsmEmitter$boolToString(destinations.cE),
  		_Utils_ap(
  			$author$project$AsmEmitter$boolToString(destinations.dd),
  			$author$project$AsmEmitter$boolToString(destinations.dI)));
  };
  var $author$project$AsmEmitter$emitJump = function (jump) {
  	return _Utils_ap(
  		$author$project$AsmEmitter$boolToString(jump.dH),
  		_Utils_ap(
  			$author$project$AsmEmitter$boolToString(jump.dj),
  			$author$project$AsmEmitter$boolToString(jump.dp)));
  };
  var $icidasset$elm_binary$Binary$Bits = $elm$core$Basics$identity;
  var $elm$core$List$repeatHelp = F3(
  	function (result, n, value) {
  		repeatHelp:
  		while (true) {
  			if (n <= 0) {
  				return result;
  			} else {
  				var $temp$result = A2($elm$core$List$cons, value, result),
  					$temp$n = n - 1,
  					$temp$value = value;
  				result = $temp$result;
  				n = $temp$n;
  				value = $temp$value;
  				continue repeatHelp;
  			}
  		}
  	});
  var $elm$core$List$repeat = F2(
  	function (n, value) {
  		return A3($elm$core$List$repeatHelp, _List_Nil, n, value);
  	});
  var $icidasset$elm_binary$Binary$ensureSize = F2(
  	function (size, _v0) {
  		var bits = _v0;
  		var currentLength = $elm$core$List$length(bits);
  		return _Utils_eq(currentLength, size) ? bits : ((_Utils_cmp(currentLength, size) > 0) ? A2($elm$core$List$drop, currentLength - size, bits) : _Utils_ap(
  			A2($elm$core$List$repeat, size - currentLength, false),
  			bits));
  	});
  var $icidasset$elm_binary$Binary$fromDecimal_ = F2(
  	function (acc, n) {
  		fromDecimal_:
  		while (true) {
  			var _v0 = _Utils_Tuple2((n / 2) | 0, n % 2);
  			var x = _v0.a;
  			var bit = _v0.b;
  			var bits = A2(
  				$elm$core$List$cons,
  				A2($elm$core$Basics$modBy, 2, bit),
  				acc);
  			if (x > 0) {
  				var $temp$acc = bits,
  					$temp$n = x;
  				acc = $temp$acc;
  				n = $temp$n;
  				continue fromDecimal_;
  			} else {
  				return bits;
  			}
  		}
  	});
  var $icidasset$elm_binary$Binary$ifThenElse = F3(
  	function (bool, a, b) {
  		return bool ? a : b;
  	});
  var $icidasset$elm_binary$Binary$fromIntegers = A2(
  	$elm$core$Basics$composeR,
  	$elm$core$List$map(
  		function (i) {
  			return A3($icidasset$elm_binary$Binary$ifThenElse, i <= 0, false, true);
  		}),
  	$elm$core$Basics$identity);
  var $icidasset$elm_binary$Binary$fromDecimal = A2(
  	$elm$core$Basics$composeR,
  	$icidasset$elm_binary$Binary$fromDecimal_(_List_Nil),
  	$icidasset$elm_binary$Binary$fromIntegers);
  var $elm$core$String$cons = _String_cons;
  var $elm$core$String$fromChar = function (_char) {
  	return A2($elm$core$String$cons, _char, '');
  };
  var $elm$core$String$repeatHelp = F3(
  	function (n, chunk, result) {
  		return (n <= 0) ? result : A3(
  			$elm$core$String$repeatHelp,
  			n >> 1,
  			_Utils_ap(chunk, chunk),
  			(!(n & 1)) ? result : _Utils_ap(result, chunk));
  	});
  var $elm$core$String$repeat = F2(
  	function (n, chunk) {
  		return A3($elm$core$String$repeatHelp, n, chunk, '');
  	});
  var $elm$core$String$padLeft = F3(
  	function (n, _char, string) {
  		return _Utils_ap(
  			A2(
  				$elm$core$String$repeat,
  				n - $elm$core$String$length(string),
  				$elm$core$String$fromChar(_char)),
  			string);
  	});
  var $icidasset$elm_binary$Binary$toIntegers = function (_v0) {
  	var bits = _v0;
  	return A2(
  		$elm$core$List$map,
  		function (b) {
  			return A3($icidasset$elm_binary$Binary$ifThenElse, b, 1, 0);
  		},
  		bits);
  };
  var $author$project$AsmEmitter$emitInstruction = function (instruction) {
  	if (!instruction.$) {
  		var number = instruction.a;
  		return A2(
  			$elm$core$String$join,
  			'',
  			A2(
  				$elm$core$List$map,
  				$elm$core$String$fromInt,
  				$icidasset$elm_binary$Binary$toIntegers(
  					A2(
  						$icidasset$elm_binary$Binary$ensureSize,
  						32,
  						$icidasset$elm_binary$Binary$fromDecimal(number)))));
  	} else {
  		var destinations = instruction.a.dg;
  		var computation = instruction.a.c8;
  		var jump = instruction.a.dE;
  		return A3(
  			$elm$core$String$padLeft,
  			32,
  			'1',
  			_Utils_ap(
  				$author$project$AsmEmitter$emitComputation(computation),
  				_Utils_ap(
  					$author$project$AsmEmitter$emitDestinations(destinations),
  					$author$project$AsmEmitter$emitJump(jump))));
  	}
  };
  var $author$project$AsmEmitter$emit = function (instructions) {
  	return A2(
  		$elm$core$String$join,
  		'\n',
  		A2($elm$core$List$map, $author$project$AsmEmitter$emitInstruction, instructions));
  };
  var $author$project$Assembler$assembleInstruction = F2(
  	function (lineNumber, instruction) {
  		var _v0 = $author$project$AsmParser$parse(instruction);
  		if (_v0.$ === 1) {
  			var err = _v0.a;
  			return $elm$core$Result$Err(
  				A3(
  					$author$project$AsmParser$showDeadEnds,
  					$elm$core$Maybe$Just(lineNumber),
  					instruction,
  					err));
  		} else {
  			var ast = _v0.a;
  			return $elm$core$Result$Ok(
  				$author$project$AsmEmitter$emit(ast));
  		}
  	});
  var $author$project$CpuEmulator$stopEditingInstruction = F2(
  	function (index, model) {
  		var prevComputer = model.d;
  		var nextComputer = function () {
  			var _v0 = A2($elm$core$Array$get, prevComputer.l, model.C);
  			if (!_v0.$) {
  				var instructionStr = _v0.a;
  				var _v1 = A2($author$project$Assembler$assembleInstruction, prevComputer.l, instructionStr);
  				if (_v1.$ === 1) {
  					var err = _v1.a;
  					return _Utils_update(
  						prevComputer,
  						{
  							K: $elm$core$Maybe$Just(
  								_Utils_Tuple2(prevComputer.l, err))
  						});
  				} else {
  					return _Utils_update(
  						prevComputer,
  						{K: $elm$core$Maybe$Nothing});
  				}
  			} else {
  				return prevComputer;
  			}
  		}();
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{d: nextComputer, av: $elm$core$Maybe$Nothing}),
  			$elm$core$Platform$Cmd$none);
  	});
  var $elm$core$Elm$JsArray$appendN = _JsArray_appendN;
  var $elm$core$Elm$JsArray$slice = _JsArray_slice;
  var $elm$core$Array$appendHelpBuilder = F2(
  	function (tail, builder) {
  		var tailLen = $elm$core$Elm$JsArray$length(tail);
  		var notAppended = ($elm$core$Array$branchFactor - $elm$core$Elm$JsArray$length(builder.h)) - tailLen;
  		var appended = A3($elm$core$Elm$JsArray$appendN, $elm$core$Array$branchFactor, builder.h, tail);
  		return (notAppended < 0) ? {
  			i: A2(
  				$elm$core$List$cons,
  				$elm$core$Array$Leaf(appended),
  				builder.i),
  			f: builder.f + 1,
  			h: A3($elm$core$Elm$JsArray$slice, notAppended, tailLen, tail)
  		} : ((!notAppended) ? {
  			i: A2(
  				$elm$core$List$cons,
  				$elm$core$Array$Leaf(appended),
  				builder.i),
  			f: builder.f + 1,
  			h: $elm$core$Elm$JsArray$empty
  		} : {i: builder.i, f: builder.f, h: appended});
  	});
  var $elm$core$Elm$JsArray$push = _JsArray_push;
  var $elm$core$Elm$JsArray$singleton = _JsArray_singleton;
  var $elm$core$Array$insertTailInTree = F4(
  	function (shift, index, tail, tree) {
  		var pos = $elm$core$Array$bitMask & (index >>> shift);
  		if (_Utils_cmp(
  			pos,
  			$elm$core$Elm$JsArray$length(tree)) > -1) {
  			if (shift === 5) {
  				return A2(
  					$elm$core$Elm$JsArray$push,
  					$elm$core$Array$Leaf(tail),
  					tree);
  			} else {
  				var newSub = $elm$core$Array$SubTree(
  					A4($elm$core$Array$insertTailInTree, shift - $elm$core$Array$shiftStep, index, tail, $elm$core$Elm$JsArray$empty));
  				return A2($elm$core$Elm$JsArray$push, newSub, tree);
  			}
  		} else {
  			var value = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
  			if (!value.$) {
  				var subTree = value.a;
  				var newSub = $elm$core$Array$SubTree(
  					A4($elm$core$Array$insertTailInTree, shift - $elm$core$Array$shiftStep, index, tail, subTree));
  				return A3($elm$core$Elm$JsArray$unsafeSet, pos, newSub, tree);
  			} else {
  				var newSub = $elm$core$Array$SubTree(
  					A4(
  						$elm$core$Array$insertTailInTree,
  						shift - $elm$core$Array$shiftStep,
  						index,
  						tail,
  						$elm$core$Elm$JsArray$singleton(value)));
  				return A3($elm$core$Elm$JsArray$unsafeSet, pos, newSub, tree);
  			}
  		}
  	});
  var $elm$core$Array$unsafeReplaceTail = F2(
  	function (newTail, _v0) {
  		var len = _v0.a;
  		var startShift = _v0.b;
  		var tree = _v0.c;
  		var tail = _v0.d;
  		var originalTailLen = $elm$core$Elm$JsArray$length(tail);
  		var newTailLen = $elm$core$Elm$JsArray$length(newTail);
  		var newArrayLen = len + (newTailLen - originalTailLen);
  		if (_Utils_eq(newTailLen, $elm$core$Array$branchFactor)) {
  			var overflow = _Utils_cmp(newArrayLen >>> $elm$core$Array$shiftStep, 1 << startShift) > 0;
  			if (overflow) {
  				var newShift = startShift + $elm$core$Array$shiftStep;
  				var newTree = A4(
  					$elm$core$Array$insertTailInTree,
  					newShift,
  					len,
  					newTail,
  					$elm$core$Elm$JsArray$singleton(
  						$elm$core$Array$SubTree(tree)));
  				return A4($elm$core$Array$Array_elm_builtin, newArrayLen, newShift, newTree, $elm$core$Elm$JsArray$empty);
  			} else {
  				return A4(
  					$elm$core$Array$Array_elm_builtin,
  					newArrayLen,
  					startShift,
  					A4($elm$core$Array$insertTailInTree, startShift, len, newTail, tree),
  					$elm$core$Elm$JsArray$empty);
  			}
  		} else {
  			return A4($elm$core$Array$Array_elm_builtin, newArrayLen, startShift, tree, newTail);
  		}
  	});
  var $elm$core$Array$appendHelpTree = F2(
  	function (toAppend, array) {
  		var len = array.a;
  		var tree = array.c;
  		var tail = array.d;
  		var itemsToAppend = $elm$core$Elm$JsArray$length(toAppend);
  		var notAppended = ($elm$core$Array$branchFactor - $elm$core$Elm$JsArray$length(tail)) - itemsToAppend;
  		var appended = A3($elm$core$Elm$JsArray$appendN, $elm$core$Array$branchFactor, tail, toAppend);
  		var newArray = A2($elm$core$Array$unsafeReplaceTail, appended, array);
  		if (notAppended < 0) {
  			var nextTail = A3($elm$core$Elm$JsArray$slice, notAppended, itemsToAppend, toAppend);
  			return A2($elm$core$Array$unsafeReplaceTail, nextTail, newArray);
  		} else {
  			return newArray;
  		}
  	});
  var $elm$core$Elm$JsArray$foldl = _JsArray_foldl;
  var $elm$core$Array$builderFromArray = function (_v0) {
  	var len = _v0.a;
  	var tree = _v0.c;
  	var tail = _v0.d;
  	var helper = F2(
  		function (node, acc) {
  			if (!node.$) {
  				var subTree = node.a;
  				return A3($elm$core$Elm$JsArray$foldl, helper, acc, subTree);
  			} else {
  				return A2($elm$core$List$cons, node, acc);
  			}
  		});
  	return {
  		i: A3($elm$core$Elm$JsArray$foldl, helper, _List_Nil, tree),
  		f: (len / $elm$core$Array$branchFactor) | 0,
  		h: tail
  	};
  };
  var $elm$core$Array$append = F2(
  	function (a, _v0) {
  		var aTail = a.d;
  		var bLen = _v0.a;
  		var bTree = _v0.c;
  		var bTail = _v0.d;
  		if (_Utils_cmp(bLen, $elm$core$Array$branchFactor * 4) < 1) {
  			var foldHelper = F2(
  				function (node, array) {
  					if (!node.$) {
  						var tree = node.a;
  						return A3($elm$core$Elm$JsArray$foldl, foldHelper, array, tree);
  					} else {
  						var leaf = node.a;
  						return A2($elm$core$Array$appendHelpTree, leaf, array);
  					}
  				});
  			return A2(
  				$elm$core$Array$appendHelpTree,
  				bTail,
  				A3($elm$core$Elm$JsArray$foldl, foldHelper, a, bTree));
  		} else {
  			var foldHelper = F2(
  				function (node, builder) {
  					if (!node.$) {
  						var tree = node.a;
  						return A3($elm$core$Elm$JsArray$foldl, foldHelper, builder, tree);
  					} else {
  						var leaf = node.a;
  						return A2($elm$core$Array$appendHelpBuilder, leaf, builder);
  					}
  				});
  			return A2(
  				$elm$core$Array$builderToArray,
  				true,
  				A2(
  					$elm$core$Array$appendHelpBuilder,
  					bTail,
  					A3(
  						$elm$core$Elm$JsArray$foldl,
  						foldHelper,
  						$elm$core$Array$builderFromArray(a),
  						bTree)));
  		}
  	});
  var $icidasset$elm_binary$Binary$toDecimal = function (_v0) {
  	var bits = _v0;
  	return A3(
  		$elm$core$List$foldl,
  		F2(
  			function (bit, _v1) {
  				var x = _v1.a;
  				var exponent = _v1.b;
  				return _Utils_Tuple2(
  					(A2($elm$core$Basics$pow, 2, exponent) * A3($icidasset$elm_binary$Binary$ifThenElse, bit, 1, 0)) + x,
  					exponent - 1);
  			}),
  		_Utils_Tuple2(
  			0,
  			$elm$core$List$length(bits) - 1),
  		bits).a;
  };
  var $author$project$Assembler$emitProgram = function (instructions) {
  	var strToInt = A2(
  		$elm$core$Basics$composeL,
  		$elm$core$Maybe$withDefault(0),
  		$elm$core$String$toInt);
  	return A2(
  		$elm$core$List$map,
  		A2(
  			$elm$core$Basics$composeL,
  			A2(
  				$elm$core$Basics$composeL,
  				A2($elm$core$Basics$composeL, $icidasset$elm_binary$Binary$toDecimal, $icidasset$elm_binary$Binary$fromIntegers),
  				$elm$core$List$map(strToInt)),
  			$elm$core$String$split('')),
  		A2(
  			$elm$core$String$split,
  			'\n',
  			$author$project$AsmEmitter$emit(instructions)));
  };
  var $elm$core$Array$fromListHelp = F3(
  	function (list, nodeList, nodeListSize) {
  		fromListHelp:
  		while (true) {
  			var _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, list);
  			var jsArray = _v0.a;
  			var remainingItems = _v0.b;
  			if (_Utils_cmp(
  				$elm$core$Elm$JsArray$length(jsArray),
  				$elm$core$Array$branchFactor) < 0) {
  				return A2(
  					$elm$core$Array$builderToArray,
  					true,
  					{i: nodeList, f: nodeListSize, h: jsArray});
  			} else {
  				var $temp$list = remainingItems,
  					$temp$nodeList = A2(
  					$elm$core$List$cons,
  					$elm$core$Array$Leaf(jsArray),
  					nodeList),
  					$temp$nodeListSize = nodeListSize + 1;
  				list = $temp$list;
  				nodeList = $temp$nodeList;
  				nodeListSize = $temp$nodeListSize;
  				continue fromListHelp;
  			}
  		}
  	});
  var $elm$core$Array$fromList = function (list) {
  	if (!list.b) {
  		return $elm$core$Array$empty;
  	} else {
  		return A3($elm$core$Array$fromListHelp, list, _List_Nil, 0);
  	}
  };
  var $author$project$CpuEmulator$hideProgramEditorPort = _Platform_outgoingPort(
  	'hideProgramEditorPort',
  	function ($) {
  		return $elm$json$Json$Encode$null;
  	});
  var $author$project$Assembler$destinationsToString = function (_v0) {
  	var a = _v0.cE;
  	var m = _v0.dI;
  	var d = _v0.dd;
  	return _Utils_ap(
  		a ? 'A' : '',
  		_Utils_ap(
  			m ? 'M' : '',
  			d ? 'D' : ''));
  };
  var $author$project$Assembler$jumpToString = function (_v0) {
  	var lt = _v0.dH;
  	var eq = _v0.dj;
  	var gt = _v0.dp;
  	var _v1 = _Utils_Tuple3(lt, eq, gt);
  	if (!_v1.a) {
  		if (!_v1.b) {
  			if (!_v1.c) {
  				return '';
  			} else {
  				return 'JGT';
  			}
  		} else {
  			if (!_v1.c) {
  				return 'JEQ';
  			} else {
  				return 'JGE';
  			}
  		}
  	} else {
  		if (!_v1.b) {
  			if (!_v1.c) {
  				return 'JLT';
  			} else {
  				return 'JNE';
  			}
  		} else {
  			if (!_v1.c) {
  				return 'JLE';
  			} else {
  				return 'JMP';
  			}
  		}
  	}
  };
  var $author$project$Assembler$instructionToString = function (instruction) {
  	if (!instruction.$) {
  		var number = instruction.a;
  		return '@' + $elm$core$String$fromInt(number);
  	} else {
  		var destinations = instruction.a.dg;
  		var computation = instruction.a.c8;
  		var jump = instruction.a.dE;
  		return _Utils_ap(
  			function () {
  				var _v1 = $author$project$Assembler$destinationsToString(destinations);
  				if (_v1 === '') {
  					return '';
  				} else {
  					var str = _v1;
  					return str + '=';
  				}
  			}(),
  			_Utils_ap(
  				computation,
  				function () {
  					var _v2 = $author$project$Assembler$jumpToString(jump);
  					if (_v2 === '') {
  						return '';
  					} else {
  						var str = _v2;
  						return ';' + str;
  					}
  				}()));
  	}
  };
  var $elm$core$Array$length = function (_v0) {
  	var len = _v0.a;
  	return len;
  };
  var $elm$core$Array$sliceLeft = F2(
  	function (from, array) {
  		var len = array.a;
  		var tree = array.c;
  		var tail = array.d;
  		if (!from) {
  			return array;
  		} else {
  			if (_Utils_cmp(
  				from,
  				$elm$core$Array$tailIndex(len)) > -1) {
  				return A4(
  					$elm$core$Array$Array_elm_builtin,
  					len - from,
  					$elm$core$Array$shiftStep,
  					$elm$core$Elm$JsArray$empty,
  					A3(
  						$elm$core$Elm$JsArray$slice,
  						from - $elm$core$Array$tailIndex(len),
  						$elm$core$Elm$JsArray$length(tail),
  						tail));
  			} else {
  				var skipNodes = (from / $elm$core$Array$branchFactor) | 0;
  				var helper = F2(
  					function (node, acc) {
  						if (!node.$) {
  							var subTree = node.a;
  							return A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);
  						} else {
  							var leaf = node.a;
  							return A2($elm$core$List$cons, leaf, acc);
  						}
  					});
  				var leafNodes = A3(
  					$elm$core$Elm$JsArray$foldr,
  					helper,
  					_List_fromArray(
  						[tail]),
  					tree);
  				var nodesToInsert = A2($elm$core$List$drop, skipNodes, leafNodes);
  				if (!nodesToInsert.b) {
  					return $elm$core$Array$empty;
  				} else {
  					var head = nodesToInsert.a;
  					var rest = nodesToInsert.b;
  					var firstSlice = from - (skipNodes * $elm$core$Array$branchFactor);
  					var initialBuilder = {
  						i: _List_Nil,
  						f: 0,
  						h: A3(
  							$elm$core$Elm$JsArray$slice,
  							firstSlice,
  							$elm$core$Elm$JsArray$length(head),
  							head)
  					};
  					return A2(
  						$elm$core$Array$builderToArray,
  						true,
  						A3($elm$core$List$foldl, $elm$core$Array$appendHelpBuilder, initialBuilder, rest));
  				}
  			}
  		}
  	});
  var $elm$core$Array$fetchNewTail = F4(
  	function (shift, end, treeEnd, tree) {
  		fetchNewTail:
  		while (true) {
  			var pos = $elm$core$Array$bitMask & (treeEnd >>> shift);
  			var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, pos, tree);
  			if (!_v0.$) {
  				var sub = _v0.a;
  				var $temp$shift = shift - $elm$core$Array$shiftStep,
  					$temp$end = end,
  					$temp$treeEnd = treeEnd,
  					$temp$tree = sub;
  				shift = $temp$shift;
  				end = $temp$end;
  				treeEnd = $temp$treeEnd;
  				tree = $temp$tree;
  				continue fetchNewTail;
  			} else {
  				var values = _v0.a;
  				return A3($elm$core$Elm$JsArray$slice, 0, $elm$core$Array$bitMask & end, values);
  			}
  		}
  	});
  var $elm$core$Array$hoistTree = F3(
  	function (oldShift, newShift, tree) {
  		hoistTree:
  		while (true) {
  			if ((_Utils_cmp(oldShift, newShift) < 1) || (!$elm$core$Elm$JsArray$length(tree))) {
  				return tree;
  			} else {
  				var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, 0, tree);
  				if (!_v0.$) {
  					var sub = _v0.a;
  					var $temp$oldShift = oldShift - $elm$core$Array$shiftStep,
  						$temp$newShift = newShift,
  						$temp$tree = sub;
  					oldShift = $temp$oldShift;
  					newShift = $temp$newShift;
  					tree = $temp$tree;
  					continue hoistTree;
  				} else {
  					return tree;
  				}
  			}
  		}
  	});
  var $elm$core$Array$sliceTree = F3(
  	function (shift, endIdx, tree) {
  		var lastPos = $elm$core$Array$bitMask & (endIdx >>> shift);
  		var _v0 = A2($elm$core$Elm$JsArray$unsafeGet, lastPos, tree);
  		if (!_v0.$) {
  			var sub = _v0.a;
  			var newSub = A3($elm$core$Array$sliceTree, shift - $elm$core$Array$shiftStep, endIdx, sub);
  			return (!$elm$core$Elm$JsArray$length(newSub)) ? A3($elm$core$Elm$JsArray$slice, 0, lastPos, tree) : A3(
  				$elm$core$Elm$JsArray$unsafeSet,
  				lastPos,
  				$elm$core$Array$SubTree(newSub),
  				A3($elm$core$Elm$JsArray$slice, 0, lastPos + 1, tree));
  		} else {
  			return A3($elm$core$Elm$JsArray$slice, 0, lastPos, tree);
  		}
  	});
  var $elm$core$Array$sliceRight = F2(
  	function (end, array) {
  		var len = array.a;
  		var startShift = array.b;
  		var tree = array.c;
  		var tail = array.d;
  		if (_Utils_eq(end, len)) {
  			return array;
  		} else {
  			if (_Utils_cmp(
  				end,
  				$elm$core$Array$tailIndex(len)) > -1) {
  				return A4(
  					$elm$core$Array$Array_elm_builtin,
  					end,
  					startShift,
  					tree,
  					A3($elm$core$Elm$JsArray$slice, 0, $elm$core$Array$bitMask & end, tail));
  			} else {
  				var endIdx = $elm$core$Array$tailIndex(end);
  				var depth = $elm$core$Basics$floor(
  					A2(
  						$elm$core$Basics$logBase,
  						$elm$core$Array$branchFactor,
  						A2($elm$core$Basics$max, 1, endIdx - 1)));
  				var newShift = A2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep);
  				return A4(
  					$elm$core$Array$Array_elm_builtin,
  					end,
  					newShift,
  					A3(
  						$elm$core$Array$hoistTree,
  						startShift,
  						newShift,
  						A3($elm$core$Array$sliceTree, startShift, endIdx, tree)),
  					A4($elm$core$Array$fetchNewTail, startShift, end, endIdx, tree));
  			}
  		}
  	});
  var $elm$core$Array$translateIndex = F2(
  	function (index, _v0) {
  		var len = _v0.a;
  		var posIndex = (index < 0) ? (len + index) : index;
  		return (posIndex < 0) ? 0 : ((_Utils_cmp(posIndex, len) > 0) ? len : posIndex);
  	});
  var $elm$core$Array$slice = F3(
  	function (from, to, array) {
  		var correctTo = A2($elm$core$Array$translateIndex, to, array);
  		var correctFrom = A2($elm$core$Array$translateIndex, from, array);
  		return (_Utils_cmp(correctFrom, correctTo) > 0) ? $elm$core$Array$empty : A2(
  			$elm$core$Array$sliceLeft,
  			correctFrom,
  			A2($elm$core$Array$sliceRight, correctTo, array));
  	});
  var $author$project$CpuEmulator$stopEditingProgram = function (model) {
  	var _v0 = $author$project$Assembler$parseProgram(model.aA);
  	if (!_v0.$) {
  		var instructions = _v0.a;
  		var updatedPartOfRom = $elm$core$Array$fromList(
  			$author$project$Assembler$emitProgram(instructions));
  		var updatedPartOfInstructions = $elm$core$Array$fromList(
  			A2($elm$core$List$map, $author$project$Assembler$instructionToString, instructions));
  		var restOfOldInstructions = A3(
  			$elm$core$Array$slice,
  			$elm$core$Array$length(updatedPartOfInstructions),
  			$elm$core$Array$length(model.C),
  			model.C);
  		var oldComputer = model.d;
  		var restOfOldRom = A3(
  			$elm$core$Array$slice,
  			$elm$core$Array$length(updatedPartOfRom),
  			$elm$core$Array$length(oldComputer.am),
  			oldComputer.am);
  		var nextRom = A2($elm$core$Array$append, updatedPartOfRom, restOfOldRom);
  		var nextInstructions = A2($elm$core$Array$append, updatedPartOfInstructions, restOfOldInstructions);
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{
  					d: _Utils_update(
  						oldComputer,
  						{am: nextRom}),
  					C: nextInstructions,
  					ai: false
  				}),
  			$author$project$CpuEmulator$hideProgramEditorPort(0));
  	} else {
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{ai: false}),
  			$author$project$CpuEmulator$hideProgramEditorPort(0));
  	}
  };
  var $author$project$CpuEmulator$stopEditingRam = F2(
  	function (index, model) {
  		return _Utils_Tuple2(
  			_Utils_update(
  				model,
  				{aw: $elm$core$Maybe$Nothing}),
  			$elm$core$Platform$Cmd$none);
  	});
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$stopLoading = function (_v0) {
  	var model = _v0;
  	return _Utils_update(
  		model,
  		{aj: false});
  };
  var $author$project$CpuEmulator$stopRunningComputer = function (model) {
  	return _Utils_Tuple2(
  		_Utils_update(
  			model,
  			{w: true, V: false}),
  		$elm$core$Platform$Cmd$none);
  };
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$Timeout = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $elm$core$Platform$Cmd$map = _Platform_map;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$CurrTime = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$time$Time$Name = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$time$Time$Offset = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$time$Time$Zone = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $elm$time$Time$customZone = $elm$time$Time$Zone;
  var $elm$time$Time$now = _Time_now($elm$time$Time$millisToPosix);
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$shouldLoadMore = F2(
  	function (model, _v0) {
  		var scrollTop = _v0.cn;
  		var contentHeight = _v0.bI;
  		var containerHeight = _v0.bH;
  		if (model.aj) {
  			return false;
  		} else {
  			var _v1 = model.au;
  			if (!_v1) {
  				return _Utils_cmp(scrollTop, model.ay) < 1;
  			} else {
  				var excessHeight = contentHeight - containerHeight;
  				return _Utils_cmp(scrollTop, excessHeight - model.ay) > -1;
  			}
  		}
  	});
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$startLoading = function (_v0) {
  	var model = _v0;
  	return _Utils_update(
  		model,
  		{aj: true});
  };
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$scrollUpdate = F3(
  	function (mapper, pos, _v0) {
  		var model = _v0;
  		return A2($FabienHenon$elm_infinite_scroll$InfiniteScroll$shouldLoadMore, model, pos) ? _Utils_Tuple2(
  			$FabienHenon$elm_infinite_scroll$InfiniteScroll$startLoading(model),
  			A2(
  				$elm$core$Platform$Cmd$map,
  				mapper,
  				A2($elm$core$Task$perform, $FabienHenon$elm_infinite_scroll$InfiniteScroll$CurrTime, $elm$time$Time$now))) : _Utils_Tuple2(
  			model,
  			A2($elm$core$Platform$Cmd$map, mapper, $elm$core$Platform$Cmd$none));
  	});
  var $elm$core$Process$sleep = _Process_sleep;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$update = F3(
  	function (mapper, msg, _v0) {
  		var model = _v0;
  		switch (msg.$) {
  			case 0:
  				var pos = msg.a;
  				return A3($FabienHenon$elm_infinite_scroll$InfiniteScroll$scrollUpdate, mapper, pos, model);
  			case 1:
  				var time = msg.a;
  				return _Utils_Tuple2(
  					_Utils_update(
  						model,
  						{aU: time}),
  					$elm$core$Platform$Cmd$batch(
  						_List_fromArray(
  							[
  								model.aV(model.au),
  								A2(
  								$elm$core$Platform$Cmd$map,
  								mapper,
  								A2(
  									$elm$core$Task$perform,
  									$FabienHenon$elm_infinite_scroll$InfiniteScroll$Timeout(time),
  									$elm$core$Process$sleep(model.a2)))
  							])));
  			default:
  				var time = msg.a;
  				return _Utils_eq(time, model.aU) ? _Utils_Tuple2(
  					$FabienHenon$elm_infinite_scroll$InfiniteScroll$stopLoading(model),
  					A2($elm$core$Platform$Cmd$map, mapper, $elm$core$Platform$Cmd$none)) : _Utils_Tuple2(
  					model,
  					A2($elm$core$Platform$Cmd$map, mapper, $elm$core$Platform$Cmd$none));
  		}
  	});
  var $author$project$CpuEmulator$update = F2(
  	function (msg, model) {
  		switch (msg.$) {
  			case 1:
  				return $author$project$CpuEmulator$stepComputer(model);
  			case 0:
  				var time = msg.a;
  				return A2($author$project$CpuEmulator$stepComputerOneFrame, time, model);
  			case 2:
  				return $author$project$CpuEmulator$startRunningComputer(model);
  			case 3:
  				return $author$project$CpuEmulator$stopRunningComputer(model);
  			case 4:
  				return $author$project$CpuEmulator$resetComputer(model);
  			case 5:
  				var index = msg.a;
  				return A2($author$project$CpuEmulator$startEditingInstruction, index, model);
  			case 6:
  				var index = msg.a;
  				var newInstruction = msg.b;
  				return A3($author$project$CpuEmulator$editInstruction, index, newInstruction, model);
  			case 7:
  				var index = msg.a;
  				return A2($author$project$CpuEmulator$stopEditingInstruction, index, model);
  			case 8:
  				return $author$project$CpuEmulator$startEditingProgram(model);
  			case 9:
  				var newProgram = msg.a;
  				return A2($author$project$CpuEmulator$editProgram, newProgram, model);
  			case 10:
  				return $author$project$CpuEmulator$stopEditingProgram(model);
  			case 11:
  				var index = msg.a;
  				return A2($author$project$CpuEmulator$startEditingRam, index, model);
  			case 12:
  				var index = msg.a;
  				var newValue = msg.b;
  				return A3($author$project$CpuEmulator$editRam, index, newValue, model);
  			case 13:
  				var index = msg.a;
  				return A2($author$project$CpuEmulator$stopEditingRam, index, model);
  			case 14:
  				var scrollMsg = msg.a;
  				var _v1 = A3($FabienHenon$elm_infinite_scroll$InfiniteScroll$update, $author$project$CpuEmulator$RamScrollMsg, scrollMsg, model.al);
  				var nextRamScroll = _v1.a;
  				var cmd = _v1.b;
  				return _Utils_Tuple2(
  					_Utils_update(
  						model,
  						{al: nextRamScroll}),
  					cmd);
  			case 15:
  				var nextRamScroll = $FabienHenon$elm_infinite_scroll$InfiniteScroll$stopLoading(model.al);
  				return _Utils_Tuple2(
  					_Utils_update(
  						model,
  						{aB: model.aB + 200, al: nextRamScroll}),
  					$elm$core$Platform$Cmd$none);
  			case 16:
  				var scrollMsg = msg.a;
  				var _v2 = A3($FabienHenon$elm_infinite_scroll$InfiniteScroll$update, $author$project$CpuEmulator$RomScrollMsg, scrollMsg, model.an);
  				var nextRomScroll = _v2.a;
  				var cmd = _v2.b;
  				return _Utils_Tuple2(
  					_Utils_update(
  						model,
  						{an: nextRomScroll}),
  					cmd);
  			case 17:
  				var nextRomScroll = $FabienHenon$elm_infinite_scroll$InfiniteScroll$stopLoading(model.an);
  				return _Utils_Tuple2(
  					_Utils_update(
  						model,
  						{aC: model.aC + 200, an: nextRomScroll}),
  					$elm$core$Platform$Cmd$none);
  			default:
  				return _Utils_Tuple2(model, $elm$core$Platform$Cmd$none);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$AlignY = function (a) {
  	return {$: 5, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$Top = 0;
  var $mdgriffith$elm_ui$Element$alignTop = $mdgriffith$elm_ui$Internal$Model$AlignY(0);
  var $mdgriffith$elm_ui$Internal$Model$Unkeyed = function (a) {
  	return {$: 0, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$AsColumn = 1;
  var $mdgriffith$elm_ui$Internal$Model$asColumn = 1;
  var $mdgriffith$elm_ui$Internal$Style$classes = {cF: 'a', a5: 'atv', cH: 'ab', cI: 'cx', cJ: 'cy', cK: 'acb', cL: 'accx', cM: 'accy', cN: 'acr', bC: 'al', bD: 'ar', cO: 'at', a6: 'ah', a7: 'av', cQ: 's', cU: 'bh', cV: 'b', cX: 'w7', cZ: 'bd', c_: 'bdt', aK: 'bn', c$: 'bs', aL: 'cpe', c5: 'cp', c6: 'cpx', c7: 'cpy', I: 'c', aP: 'ctr', aQ: 'cb', aR: 'ccx', J: 'ccy', at: 'cl', aS: 'cr', c9: 'ct', db: 'cptr', dc: 'ctxt', dm: 'fcs', bP: 'focus-within', dn: 'fs', $7: 'g', bg: 'hbh', bh: 'hc', bT: 'he', bi: 'hf', bU: 'hfp', dr: 'hv', dt: 'ic', dv: 'fr', dx: 'iml', dy: 'imlf', dz: 'imlp', dA: 'implw', dB: 'it', dD: 'i', b2: 'lnk', ak: 'nb', b5: 'notxt', dL: 'ol', dM: 'or', Z: 'oq', dQ: 'oh', ca: 'pg', cb: 'p', dR: 'ppe', dU: 'ui', aX: 'r', dW: 'sb', dX: 'sbx', dY: 'sby', dZ: 'sbt', d$: 'e', d0: 'cap', d1: 'sev', d6: 'sk', ct: 't', d9: 'tc', ea: 'w8', eb: 'w2', ec: 'w9', ed: 'tj', a1: 'tja', ee: 'tl', ef: 'w3', eg: 'w5', eh: 'w4', ei: 'tr', ej: 'w6', ek: 'w1', el: 'tun', cv: 'ts', ab: 'clr', es: 'u', by: 'wc', cz: 'we', bz: 'wf', cA: 'wfp', bA: 'wrp'};
  var $mdgriffith$elm_ui$Internal$Model$Generic = {$: 0};
  var $mdgriffith$elm_ui$Internal$Model$div = $mdgriffith$elm_ui$Internal$Model$Generic;
  var $mdgriffith$elm_ui$Internal$Model$NoNearbyChildren = {$: 0};
  var $mdgriffith$elm_ui$Internal$Model$columnClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.I);
  var $mdgriffith$elm_ui$Internal$Model$gridClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.$7);
  var $mdgriffith$elm_ui$Internal$Model$pageClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.ca);
  var $mdgriffith$elm_ui$Internal$Model$paragraphClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cb);
  var $mdgriffith$elm_ui$Internal$Model$rowClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.aX);
  var $mdgriffith$elm_ui$Internal$Model$singleClass = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.d$);
  var $mdgriffith$elm_ui$Internal$Model$contextClasses = function (context) {
  	switch (context) {
  		case 0:
  			return $mdgriffith$elm_ui$Internal$Model$rowClass;
  		case 1:
  			return $mdgriffith$elm_ui$Internal$Model$columnClass;
  		case 2:
  			return $mdgriffith$elm_ui$Internal$Model$singleClass;
  		case 3:
  			return $mdgriffith$elm_ui$Internal$Model$gridClass;
  		case 4:
  			return $mdgriffith$elm_ui$Internal$Model$paragraphClass;
  		default:
  			return $mdgriffith$elm_ui$Internal$Model$pageClass;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$Keyed = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$NoStyleSheet = {$: 0};
  var $mdgriffith$elm_ui$Internal$Model$Styled = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$Unstyled = function (a) {
  	return {$: 0, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$addChildren = F2(
  	function (existing, nearbyChildren) {
  		switch (nearbyChildren.$) {
  			case 0:
  				return existing;
  			case 1:
  				var behind = nearbyChildren.a;
  				return _Utils_ap(behind, existing);
  			case 2:
  				var inFront = nearbyChildren.a;
  				return _Utils_ap(existing, inFront);
  			default:
  				var behind = nearbyChildren.a;
  				var inFront = nearbyChildren.b;
  				return _Utils_ap(
  					behind,
  					_Utils_ap(existing, inFront));
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$addKeyedChildren = F3(
  	function (key, existing, nearbyChildren) {
  		switch (nearbyChildren.$) {
  			case 0:
  				return existing;
  			case 1:
  				var behind = nearbyChildren.a;
  				return _Utils_ap(
  					A2(
  						$elm$core$List$map,
  						function (x) {
  							return _Utils_Tuple2(key, x);
  						},
  						behind),
  					existing);
  			case 2:
  				var inFront = nearbyChildren.a;
  				return _Utils_ap(
  					existing,
  					A2(
  						$elm$core$List$map,
  						function (x) {
  							return _Utils_Tuple2(key, x);
  						},
  						inFront));
  			default:
  				var behind = nearbyChildren.a;
  				var inFront = nearbyChildren.b;
  				return _Utils_ap(
  					A2(
  						$elm$core$List$map,
  						function (x) {
  							return _Utils_Tuple2(key, x);
  						},
  						behind),
  					_Utils_ap(
  						existing,
  						A2(
  							$elm$core$List$map,
  							function (x) {
  								return _Utils_Tuple2(key, x);
  							},
  							inFront)));
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$AsEl = 2;
  var $mdgriffith$elm_ui$Internal$Model$asEl = 2;
  var $mdgriffith$elm_ui$Internal$Model$AsParagraph = 4;
  var $mdgriffith$elm_ui$Internal$Model$asParagraph = 4;
  var $mdgriffith$elm_ui$Internal$Flag$Flag = function (a) {
  	return {$: 0, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Flag$Second = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Flag$flag = function (i) {
  	return (i > 31) ? $mdgriffith$elm_ui$Internal$Flag$Second(1 << (i - 32)) : $mdgriffith$elm_ui$Internal$Flag$Flag(1 << i);
  };
  var $mdgriffith$elm_ui$Internal$Flag$alignBottom = $mdgriffith$elm_ui$Internal$Flag$flag(41);
  var $mdgriffith$elm_ui$Internal$Flag$alignRight = $mdgriffith$elm_ui$Internal$Flag$flag(40);
  var $mdgriffith$elm_ui$Internal$Flag$centerX = $mdgriffith$elm_ui$Internal$Flag$flag(42);
  var $mdgriffith$elm_ui$Internal$Flag$centerY = $mdgriffith$elm_ui$Internal$Flag$flag(43);
  var $elm$html$Html$Attributes$stringProperty = F2(
  	function (key, string) {
  		return A2(
  			_VirtualDom_property,
  			key,
  			$elm$json$Json$Encode$string(string));
  	});
  var $elm$html$Html$Attributes$class = $elm$html$Html$Attributes$stringProperty('className');
  var $elm$html$Html$div = _VirtualDom_node('div');
  var $mdgriffith$elm_ui$Internal$Model$lengthClassName = function (x) {
  	switch (x.$) {
  		case 0:
  			var px = x.a;
  			return $elm$core$String$fromInt(px) + 'px';
  		case 1:
  			return 'auto';
  		case 2:
  			var i = x.a;
  			return $elm$core$String$fromInt(i) + 'fr';
  		case 3:
  			var min = x.a;
  			var len = x.b;
  			return 'min' + ($elm$core$String$fromInt(min) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len));
  		default:
  			var max = x.a;
  			var len = x.b;
  			return 'max' + ($elm$core$String$fromInt(max) + $mdgriffith$elm_ui$Internal$Model$lengthClassName(len));
  	}
  };
  var $elm$core$Basics$round = _Basics_round;
  var $mdgriffith$elm_ui$Internal$Model$floatClass = function (x) {
  	return $elm$core$String$fromInt(
  		$elm$core$Basics$round(x * 255));
  };
  var $mdgriffith$elm_ui$Internal$Model$transformClass = function (transform) {
  	switch (transform.$) {
  		case 0:
  			return $elm$core$Maybe$Nothing;
  		case 1:
  			var _v1 = transform.a;
  			var x = _v1.a;
  			var y = _v1.b;
  			var z = _v1.c;
  			return $elm$core$Maybe$Just(
  				'mv-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(x) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(y) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(z))))));
  		default:
  			var _v2 = transform.a;
  			var tx = _v2.a;
  			var ty = _v2.b;
  			var tz = _v2.c;
  			var _v3 = transform.b;
  			var sx = _v3.a;
  			var sy = _v3.b;
  			var sz = _v3.c;
  			var _v4 = transform.c;
  			var ox = _v4.a;
  			var oy = _v4.b;
  			var oz = _v4.c;
  			var angle = transform.d;
  			return $elm$core$Maybe$Just(
  				'tfrm-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ty) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(tz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sx) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(sz) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(ox) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oy) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(oz) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(angle))))))))))))))))))));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$getStyleName = function (style) {
  	switch (style.$) {
  		case 13:
  			var name = style.a;
  			return name;
  		case 12:
  			var name = style.a;
  			var o = style.b;
  			return name;
  		case 0:
  			var _class = style.a;
  			return _class;
  		case 1:
  			var name = style.a;
  			return name;
  		case 2:
  			var i = style.a;
  			return 'font-size-' + $elm$core$String$fromInt(i);
  		case 3:
  			var _class = style.a;
  			return _class;
  		case 4:
  			var _class = style.a;
  			return _class;
  		case 5:
  			var cls = style.a;
  			var x = style.b;
  			var y = style.c;
  			return cls;
  		case 7:
  			var cls = style.a;
  			var top = style.b;
  			var right = style.c;
  			var bottom = style.d;
  			var left = style.e;
  			return cls;
  		case 6:
  			var cls = style.a;
  			var top = style.b;
  			var right = style.c;
  			var bottom = style.d;
  			var left = style.e;
  			return cls;
  		case 8:
  			var template = style.a;
  			return 'grid-rows-' + (A2(
  				$elm$core$String$join,
  				'-',
  				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.dV)) + ('-cols-' + (A2(
  				$elm$core$String$join,
  				'-',
  				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.bb)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.d2.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.d2.b)))))));
  		case 9:
  			var pos = style.a;
  			return 'gp grid-pos-' + ($elm$core$String$fromInt(pos.aX) + ('-' + ($elm$core$String$fromInt(pos.aO) + ('-' + ($elm$core$String$fromInt(pos.aJ) + ('-' + $elm$core$String$fromInt(pos.bS)))))));
  		case 11:
  			var selector = style.a;
  			var subStyle = style.b;
  			var name = function () {
  				switch (selector) {
  					case 0:
  						return 'fs';
  					case 1:
  						return 'hv';
  					default:
  						return 'act';
  				}
  			}();
  			return A2(
  				$elm$core$String$join,
  				' ',
  				A2(
  					$elm$core$List$map,
  					function (sty) {
  						var _v1 = $mdgriffith$elm_ui$Internal$Model$getStyleName(sty);
  						if (_v1 === '') {
  							return '';
  						} else {
  							var styleName = _v1;
  							return styleName + ('-' + name);
  						}
  					},
  					subStyle));
  		default:
  			var x = style.a;
  			return A2(
  				$elm$core$Maybe$withDefault,
  				'',
  				$mdgriffith$elm_ui$Internal$Model$transformClass(x));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$reduceStyles = F2(
  	function (style, nevermind) {
  		var cache = nevermind.a;
  		var existing = nevermind.b;
  		var styleName = $mdgriffith$elm_ui$Internal$Model$getStyleName(style);
  		return A2($elm$core$Set$member, styleName, cache) ? nevermind : _Utils_Tuple2(
  			A2($elm$core$Set$insert, styleName, cache),
  			A2($elm$core$List$cons, style, existing));
  	});
  var $mdgriffith$elm_ui$Internal$Model$Property = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$Style = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$dot = function (c) {
  	return '.' + c;
  };
  var $elm$core$List$maybeCons = F3(
  	function (f, mx, xs) {
  		var _v0 = f(mx);
  		if (!_v0.$) {
  			var x = _v0.a;
  			return A2($elm$core$List$cons, x, xs);
  		} else {
  			return xs;
  		}
  	});
  var $elm$core$List$filterMap = F2(
  	function (f, xs) {
  		return A3(
  			$elm$core$List$foldr,
  			$elm$core$List$maybeCons(f),
  			_List_Nil,
  			xs);
  	});
  var $elm$core$String$fromFloat = _String_fromNumber;
  var $mdgriffith$elm_ui$Internal$Model$formatColor = function (_v0) {
  	var red = _v0.a;
  	var green = _v0.b;
  	var blue = _v0.c;
  	var alpha = _v0.d;
  	return 'rgba(' + ($elm$core$String$fromInt(
  		$elm$core$Basics$round(red * 255)) + ((',' + $elm$core$String$fromInt(
  		$elm$core$Basics$round(green * 255))) + ((',' + $elm$core$String$fromInt(
  		$elm$core$Basics$round(blue * 255))) + (',' + ($elm$core$String$fromFloat(alpha) + ')')))));
  };
  var $mdgriffith$elm_ui$Internal$Model$formatBoxShadow = function (shadow) {
  	return A2(
  		$elm$core$String$join,
  		' ',
  		A2(
  			$elm$core$List$filterMap,
  			$elm$core$Basics$identity,
  			_List_fromArray(
  				[
  					shadow.bY ? $elm$core$Maybe$Just('inset') : $elm$core$Maybe$Nothing,
  					$elm$core$Maybe$Just(
  					$elm$core$String$fromFloat(shadow.ay.a) + 'px'),
  					$elm$core$Maybe$Just(
  					$elm$core$String$fromFloat(shadow.ay.b) + 'px'),
  					$elm$core$Maybe$Just(
  					$elm$core$String$fromFloat(shadow.ad) + 'px'),
  					$elm$core$Maybe$Just(
  					$elm$core$String$fromFloat(shadow.aZ) + 'px'),
  					$elm$core$Maybe$Just(
  					$mdgriffith$elm_ui$Internal$Model$formatColor(shadow.af))
  				])));
  };
  var $elm$core$Maybe$map = F2(
  	function (f, maybe) {
  		if (!maybe.$) {
  			var value = maybe.a;
  			return $elm$core$Maybe$Just(
  				f(value));
  		} else {
  			return $elm$core$Maybe$Nothing;
  		}
  	});
  var $elm$core$Tuple$mapFirst = F2(
  	function (func, _v0) {
  		var x = _v0.a;
  		var y = _v0.b;
  		return _Utils_Tuple2(
  			func(x),
  			y);
  	});
  var $elm$core$Tuple$mapSecond = F2(
  	function (func, _v0) {
  		var x = _v0.a;
  		var y = _v0.b;
  		return _Utils_Tuple2(
  			x,
  			func(y));
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderFocusStyle = function (focus) {
  	return _List_fromArray(
  		[
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$Style,
  			$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bP) + ':focus-within',
  			A2(
  				$elm$core$List$filterMap,
  				$elm$core$Basics$identity,
  				_List_fromArray(
  					[
  						A2(
  						$elm$core$Maybe$map,
  						function (color) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'border-color',
  								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
  						},
  						focus.cY),
  						A2(
  						$elm$core$Maybe$map,
  						function (color) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'background-color',
  								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
  						},
  						focus.cS),
  						A2(
  						$elm$core$Maybe$map,
  						function (shadow) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'box-shadow',
  								$mdgriffith$elm_ui$Internal$Model$formatBoxShadow(
  									{
  										ad: shadow.ad,
  										af: shadow.af,
  										bY: false,
  										ay: A2(
  											$elm$core$Tuple$mapSecond,
  											$elm$core$Basics$toFloat,
  											A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.ay)),
  										aZ: shadow.aZ
  									}));
  						},
  						focus.d_),
  						$elm$core$Maybe$Just(
  						A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none'))
  					]))),
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$Style,
  			$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + (':focus .focusable, ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + '.focusable:focus')),
  			A2(
  				$elm$core$List$filterMap,
  				$elm$core$Basics$identity,
  				_List_fromArray(
  					[
  						A2(
  						$elm$core$Maybe$map,
  						function (color) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'border-color',
  								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
  						},
  						focus.cY),
  						A2(
  						$elm$core$Maybe$map,
  						function (color) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'background-color',
  								$mdgriffith$elm_ui$Internal$Model$formatColor(color));
  						},
  						focus.cS),
  						A2(
  						$elm$core$Maybe$map,
  						function (shadow) {
  							return A2(
  								$mdgriffith$elm_ui$Internal$Model$Property,
  								'box-shadow',
  								$mdgriffith$elm_ui$Internal$Model$formatBoxShadow(
  									{
  										ad: shadow.ad,
  										af: shadow.af,
  										bY: false,
  										ay: A2(
  											$elm$core$Tuple$mapSecond,
  											$elm$core$Basics$toFloat,
  											A2($elm$core$Tuple$mapFirst, $elm$core$Basics$toFloat, shadow.ay)),
  										aZ: shadow.aZ
  									}));
  						},
  						focus.d_),
  						$elm$core$Maybe$Just(
  						A2($mdgriffith$elm_ui$Internal$Model$Property, 'outline', 'none'))
  					])))
  		]);
  };
  var $elm$virtual_dom$VirtualDom$node = function (tag) {
  	return _VirtualDom_node(
  		_VirtualDom_noScript(tag));
  };
  var $elm$virtual_dom$VirtualDom$property = F2(
  	function (key, value) {
  		return A2(
  			_VirtualDom_property,
  			_VirtualDom_noInnerHtmlOrFormAction(key),
  			_VirtualDom_noJavaScriptOrHtmlUri(value));
  	});
  var $mdgriffith$elm_ui$Internal$Style$Batch = function (a) {
  	return {$: 5, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Style$Child = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$Class = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$Descriptor = F2(
  	function (a, b) {
  		return {$: 3, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$Left = 3;
  var $mdgriffith$elm_ui$Internal$Style$Prop = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$Right = 2;
  var $mdgriffith$elm_ui$Internal$Style$Self = $elm$core$Basics$identity;
  var $mdgriffith$elm_ui$Internal$Style$Supports = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Style$Content = $elm$core$Basics$identity;
  var $mdgriffith$elm_ui$Internal$Style$Bottom = 1;
  var $mdgriffith$elm_ui$Internal$Style$CenterX = 4;
  var $mdgriffith$elm_ui$Internal$Style$CenterY = 5;
  var $mdgriffith$elm_ui$Internal$Style$Top = 0;
  var $mdgriffith$elm_ui$Internal$Style$alignments = _List_fromArray(
  	[0, 1, 2, 3, 4, 5]);
  var $elm$core$List$append = F2(
  	function (xs, ys) {
  		if (!ys.b) {
  			return xs;
  		} else {
  			return A3($elm$core$List$foldr, $elm$core$List$cons, ys, xs);
  		}
  	});
  var $elm$core$List$concat = function (lists) {
  	return A3($elm$core$List$foldr, $elm$core$List$append, _List_Nil, lists);
  };
  var $elm$core$List$concatMap = F2(
  	function (f, list) {
  		return $elm$core$List$concat(
  			A2($elm$core$List$map, f, list));
  	});
  var $mdgriffith$elm_ui$Internal$Style$contentName = function (desc) {
  	switch (desc) {
  		case 0:
  			var _v1 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c9);
  		case 1:
  			var _v2 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aQ);
  		case 2:
  			var _v3 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aS);
  		case 3:
  			var _v4 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.at);
  		case 4:
  			var _v5 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aR);
  		default:
  			var _v6 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.J);
  	}
  };
  var $mdgriffith$elm_ui$Internal$Style$selfName = function (desc) {
  	switch (desc) {
  		case 0:
  			var _v1 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cO);
  		case 1:
  			var _v2 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cH);
  		case 2:
  			var _v3 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bD);
  		case 3:
  			var _v4 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bC);
  		case 4:
  			var _v5 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cI);
  		default:
  			var _v6 = desc;
  			return $mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cJ);
  	}
  };
  var $mdgriffith$elm_ui$Internal$Style$describeAlignment = function (values) {
  	var createDescription = function (alignment) {
  		var _v0 = values(alignment);
  		var content = _v0.a;
  		var indiv = _v0.b;
  		return _List_fromArray(
  			[
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$contentName(alignment),
  				content),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Child,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$selfName(alignment),
  						indiv)
  					]))
  			]);
  	};
  	return $mdgriffith$elm_ui$Internal$Style$Batch(
  		A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments));
  };
  var $mdgriffith$elm_ui$Internal$Style$elDescription = _List_fromArray(
  	[
  		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
  		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'),
  		A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Descriptor,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bg),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Child,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cU),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1')
  					]))
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Descriptor,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dZ),
  		_List_fromArray(
  			[
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Child,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ct),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'auto !important')
  							]))
  					]))
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Child,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bh),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Child,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Child,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Child,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cA),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Child,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
  			])),
  		$mdgriffith$elm_ui$Internal$Style$describeAlignment(
  		function (alignment) {
  			switch (alignment) {
  				case 0:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important')
  							]));
  				case 1:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important')
  							]));
  				case 2:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
  							]));
  				case 3:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
  							]));
  				case 4:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
  							]));
  				default:
  					return _Utils_Tuple2(
  						_List_fromArray(
  							[
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto')
  									]))
  							]),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
  							]));
  			}
  		})
  	]);
  var $mdgriffith$elm_ui$Internal$Style$gridAlignments = function (values) {
  	var createDescription = function (alignment) {
  		return _List_fromArray(
  			[
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Child,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$selfName(alignment),
  						values(alignment))
  					]))
  			]);
  	};
  	return $mdgriffith$elm_ui$Internal$Style$Batch(
  		A2($elm$core$List$concatMap, createDescription, $mdgriffith$elm_ui$Internal$Style$alignments));
  };
  var $mdgriffith$elm_ui$Internal$Style$Above = 0;
  var $mdgriffith$elm_ui$Internal$Style$Behind = 5;
  var $mdgriffith$elm_ui$Internal$Style$Below = 1;
  var $mdgriffith$elm_ui$Internal$Style$OnLeft = 3;
  var $mdgriffith$elm_ui$Internal$Style$OnRight = 2;
  var $mdgriffith$elm_ui$Internal$Style$Within = 4;
  var $mdgriffith$elm_ui$Internal$Style$locations = function () {
  	var loc = 0;
  	var _v0 = function () {
  		switch (loc) {
  			case 0:
  				return 0;
  			case 1:
  				return 0;
  			case 2:
  				return 0;
  			case 3:
  				return 0;
  			case 4:
  				return 0;
  			default:
  				return 0;
  		}
  	}();
  	return _List_fromArray(
  		[0, 1, 2, 3, 4, 5]);
  }();
  var $mdgriffith$elm_ui$Internal$Style$baseSheet = _List_fromArray(
  	[
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		'html,body',
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		_Utils_ap(
  			$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  			_Utils_ap(
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dt))),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + ':focus',
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'outline', 'none')
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dU),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'min-height', '100%'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				_Utils_ap(
  					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi)),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Child,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dv),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ak),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed')
  							]))
  					]))
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ak),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  				$mdgriffith$elm_ui$Internal$Style$elDescription),
  				$mdgriffith$elm_ui$Internal$Style$Batch(
  				function (fn) {
  					return A2($elm$core$List$map, fn, $mdgriffith$elm_ui$Internal$Style$locations);
  				}(
  					function (loc) {
  						switch (loc) {
  							case 0:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cF),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
  												])),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz),
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  												])),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												]))
  										]));
  							case 1:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cV),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'bottom', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												])),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', 'auto')
  												]))
  										]));
  							case 2:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dM),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												]))
  										]));
  							case 3:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dL),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'right', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '20'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												]))
  										]));
  							case 4:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dv),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												]))
  										]));
  							default:
  								return A2(
  									$mdgriffith$elm_ui$Internal$Style$Descriptor,
  									$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cU),
  									_List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'absolute'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none'),
  											A2(
  											$mdgriffith$elm_ui$Internal$Style$Child,
  											'*',
  											_List_fromArray(
  												[
  													A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto')
  												]))
  										]));
  						}
  					}))
  			])),
  		A2(
  		$mdgriffith$elm_ui$Internal$Style$Class,
  		$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  		_List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'relative'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border', 'none'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '0'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'resize', 'none'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', 'inherit'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'box-sizing', 'border-box'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'padding', '0'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-size', 'inherit'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'inherit'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-family', 'inherit'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', 'inherit'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'none'),
  				A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'inherit'),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bA),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-wrap', 'wrap')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.b5),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-moz-user-select', 'none'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-webkit-user-select', 'none'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, '-ms-user-select', 'none'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'user-select', 'none')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.db),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'pointer')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dc),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dR),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none !important')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aL),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'auto !important')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ab),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.Z),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.dr, $mdgriffith$elm_ui$Internal$Style$classes.ab)) + ':hover',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.dr, $mdgriffith$elm_ui$Internal$Style$classes.Z)) + ':hover',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.dm, $mdgriffith$elm_ui$Internal$Style$classes.ab)) + ':focus',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.dm, $mdgriffith$elm_ui$Internal$Style$classes.Z)) + ':focus',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.a5, $mdgriffith$elm_ui$Internal$Style$classes.ab)) + ':active',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '0')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot(
  					_Utils_ap($mdgriffith$elm_ui$Internal$Style$classes.a5, $mdgriffith$elm_ui$Internal$Style$classes.Z)) + ':active',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'opacity', '1')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cv),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Prop,
  						'transition',
  						A2(
  							$elm$core$String$join,
  							', ',
  							A2(
  								$elm$core$List$map,
  								function (x) {
  									return x + ' 160ms';
  								},
  								_List_fromArray(
  									['transform', 'opacity', 'filter', 'background-color', 'color', 'font-size']))))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dW),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'auto'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dX),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'auto'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aX),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dY),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'auto'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.I),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-shrink', '1')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c5),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow', 'hidden')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c6),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-x', 'hidden')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c7),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'overflow-y', 'hidden')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', 'auto')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aK),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-width', '0')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cZ),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dashed')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c_),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'dotted')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.c$),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'border-style', 'solid')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ct),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-block')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dB),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'line-height', '1.05'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background', 'transparent')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  				$mdgriffith$elm_ui$Internal$Style$elDescription),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aX),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'row'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0%'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cz),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.b2),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bU),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aP),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cN,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cL,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cI),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-left', 'auto !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cL,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cI),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-right', 'auto !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cL,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cJ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.cL + ' ~ u'),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.cN + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.cL)),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
  							])),
  						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
  						function (alignment) {
  							switch (alignment) {
  								case 0:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
  											]));
  								case 1:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
  											]));
  								case 2:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
  											]),
  										_List_Nil);
  								case 3:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
  											]),
  										_List_Nil);
  								case 4:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
  											]),
  										_List_Nil);
  								default:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
  											]));
  							}
  						}),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d1),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.I),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-direction', 'column'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', '0%'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bT),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.I),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bi),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '100000')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bz),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cA),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.by),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						'u:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cK,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:first-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cM,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cJ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', '0 !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:last-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cM,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cJ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', '0 !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:only-of-type.' + $mdgriffith$elm_ui$Internal$Style$classes.cM,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '1'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cJ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto !important'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto !important')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						's:last-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.cM + ' ~ u'),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						'u:first-of-type.' + ($mdgriffith$elm_ui$Internal$Style$classes.cK + (' ~ s.' + $mdgriffith$elm_ui$Internal$Style$classes.cM)),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0')
  							])),
  						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
  						function (alignment) {
  							switch (alignment) {
  								case 0:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-bottom', 'auto')
  											]));
  								case 1:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin-top', 'auto')
  											]));
  								case 2:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-end')
  											]));
  								case 3:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'flex-start')
  											]));
  								case 4:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
  											]),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'center')
  											]));
  								default:
  									return _Utils_Tuple2(
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
  											]),
  										_List_Nil);
  							}
  						}),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aP),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-grow', '0'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-self', 'stretch !important')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d1),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'space-between')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.$7),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', '-ms-grid'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						'.gp',
  						_List_fromArray(
  							[
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Supports,
  						_Utils_Tuple2('display', 'grid'),
  						_List_fromArray(
  							[
  								_Utils_Tuple2('display', 'grid')
  							])),
  						$mdgriffith$elm_ui$Internal$Style$gridAlignments(
  						function (alignment) {
  							switch (alignment) {
  								case 0:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-start')
  										]);
  								case 1:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'flex-end')
  										]);
  								case 2:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-end')
  										]);
  								case 3:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'flex-start')
  										]);
  								case 4:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'align-items', 'center')
  										]);
  								default:
  									return _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Internal$Style$Prop, 'justify-content', 'center')
  										]);
  							}
  						})
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ca),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ + ':first-child'),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot(
  							$mdgriffith$elm_ui$Internal$Style$classes.cQ + ($mdgriffith$elm_ui$Internal$Style$selfName(3) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.cQ))),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot(
  							$mdgriffith$elm_ui$Internal$Style$classes.cQ + ($mdgriffith$elm_ui$Internal$Style$selfName(2) + (':first-child + .' + $mdgriffith$elm_ui$Internal$Style$classes.cQ))),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'margin', '0 !important')
  							])),
  						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
  						function (alignment) {
  							switch (alignment) {
  								case 0:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								case 1:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								case 2:
  									return _Utils_Tuple2(
  										_List_Nil,
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right'),
  												A2(
  												$mdgriffith$elm_ui$Internal$Style$Descriptor,
  												'::after',
  												_List_fromArray(
  													[
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'),
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'),
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both')
  													]))
  											]));
  								case 3:
  									return _Utils_Tuple2(
  										_List_Nil,
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left'),
  												A2(
  												$mdgriffith$elm_ui$Internal$Style$Descriptor,
  												'::after',
  												_List_fromArray(
  													[
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'content', '\"\"'),
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'table'),
  														A2($mdgriffith$elm_ui$Internal$Style$Prop, 'clear', 'both')
  													]))
  											]));
  								case 4:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								default:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  							}
  						})
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dx),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'background-color', 'transparent')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dA),
  				_List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'flex-basis', 'auto')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dz),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'cursor', 'text'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dy),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'pre-wrap'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'color', 'transparent')
  							]))
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cb),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'block'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Descriptor,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.bg),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '0'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cU),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'z-index', '-1')
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ct),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal'),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dv),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cU),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cF),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cV),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dM),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Descriptor,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dL),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'flex')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ct),
  								_List_fromArray(
  									[
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
  										A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal')
  									])),
  								A2(
  								$mdgriffith$elm_ui$Internal$Style$Child,
  								$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d$),
  								_List_fromArray(
  									[
  										A2(
  										$mdgriffith$elm_ui$Internal$Style$Child,
  										$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ct),
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline'),
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'white-space', 'normal')
  											]))
  									]))
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aX),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-flex')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.I),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-flex')
  							])),
  						A2(
  						$mdgriffith$elm_ui$Internal$Style$Child,
  						$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.$7),
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'inline-grid')
  							])),
  						$mdgriffith$elm_ui$Internal$Style$describeAlignment(
  						function (alignment) {
  							switch (alignment) {
  								case 0:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								case 1:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								case 2:
  									return _Utils_Tuple2(
  										_List_Nil,
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'right')
  											]));
  								case 3:
  									return _Utils_Tuple2(
  										_List_Nil,
  										_List_fromArray(
  											[
  												A2($mdgriffith$elm_ui$Internal$Style$Prop, 'float', 'left')
  											]));
  								case 4:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  								default:
  									return _Utils_Tuple2(_List_Nil, _List_Nil);
  							}
  						})
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				'.hidden',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'display', 'none')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ek),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '100')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eb),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '200')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ef),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '300')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eh),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '400')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.eg),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '500')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ej),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '600')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cX),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '700')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ea),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '800')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ec),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-weight', '900')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.dD),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'italic')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d6),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.es),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'underline'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				_Utils_ap(
  					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.es),
  					$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d6)),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration', 'line-through underline'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip-ink', 'auto'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-decoration-skip', 'ink')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.el),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-style', 'normal')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ed),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.a1),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'justify-all')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.d9),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'center')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ei),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'right')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				$mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.ee),
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'text-align', 'left')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Descriptor,
  				'.modal',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'position', 'fixed'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'left', '0'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'top', '0'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'width', '100%'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'height', '100%'),
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'pointer-events', 'none')
  					]))
  			]))
  	]);
  var $mdgriffith$elm_ui$Internal$Style$fontVariant = function (_var) {
  	return _List_fromArray(
  		[
  			A2(
  			$mdgriffith$elm_ui$Internal$Style$Class,
  			'.v-' + _var,
  			_List_fromArray(
  				[
  					A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\"'))
  				])),
  			A2(
  			$mdgriffith$elm_ui$Internal$Style$Class,
  			'.v-' + (_var + '-off'),
  			_List_fromArray(
  				[
  					A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-feature-settings', '\"' + (_var + '\" 0'))
  				]))
  		]);
  };
  var $mdgriffith$elm_ui$Internal$Style$commonValues = $elm$core$List$concat(
  	_List_fromArray(
  		[
  			A2(
  			$elm$core$List$map,
  			function (x) {
  				return A2(
  					$mdgriffith$elm_ui$Internal$Style$Class,
  					'.border-' + $elm$core$String$fromInt(x),
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Style$Prop,
  							'border-width',
  							$elm$core$String$fromInt(x) + 'px')
  						]));
  			},
  			A2($elm$core$List$range, 0, 6)),
  			A2(
  			$elm$core$List$map,
  			function (i) {
  				return A2(
  					$mdgriffith$elm_ui$Internal$Style$Class,
  					'.font-size-' + $elm$core$String$fromInt(i),
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Style$Prop,
  							'font-size',
  							$elm$core$String$fromInt(i) + 'px')
  						]));
  			},
  			A2($elm$core$List$range, 8, 32)),
  			A2(
  			$elm$core$List$map,
  			function (i) {
  				return A2(
  					$mdgriffith$elm_ui$Internal$Style$Class,
  					'.p-' + $elm$core$String$fromInt(i),
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Style$Prop,
  							'padding',
  							$elm$core$String$fromInt(i) + 'px')
  						]));
  			},
  			A2($elm$core$List$range, 0, 24)),
  			_List_fromArray(
  			[
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Class,
  				'.v-smcp',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'small-caps')
  					])),
  				A2(
  				$mdgriffith$elm_ui$Internal$Style$Class,
  				'.v-smcp-off',
  				_List_fromArray(
  					[
  						A2($mdgriffith$elm_ui$Internal$Style$Prop, 'font-variant', 'normal')
  					]))
  			]),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('zero'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('onum'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('liga'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('dlig'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('ordn'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('tnum'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('afrc'),
  			$mdgriffith$elm_ui$Internal$Style$fontVariant('frac')
  		]));
  var $mdgriffith$elm_ui$Internal$Style$explainer = '\n.explain {\n    border: 6px solid rgb(174, 121, 15) !important;\n}\n.explain > .' + ($mdgriffith$elm_ui$Internal$Style$classes.cQ + (' {\n    border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n.ctr {\n    border: none !important;\n}\n.explain > .ctr > .' + ($mdgriffith$elm_ui$Internal$Style$classes.cQ + ' {\n    border: 4px dashed rgb(0, 151, 167) !important;\n}\n\n')));
  var $mdgriffith$elm_ui$Internal$Style$inputTextReset = '\ninput[type="search"],\ninput[type="search"]::-webkit-search-decoration,\ninput[type="search"]::-webkit-search-cancel-button,\ninput[type="search"]::-webkit-search-results-button,\ninput[type="search"]::-webkit-search-results-decoration {\n  -webkit-appearance:none;\n}\n';
  var $mdgriffith$elm_ui$Internal$Style$sliderReset = '\ninput[type=range] {\n  -webkit-appearance: none; \n  background: transparent;\n  position:absolute;\n  left:0;\n  top:0;\n  z-index:10;\n  width: 100%;\n  outline: dashed 1px;\n  height: 100%;\n  opacity: 0;\n}\n';
  var $mdgriffith$elm_ui$Internal$Style$thumbReset = '\ninput[type=range]::-webkit-slider-thumb {\n    -webkit-appearance: none;\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range]::-moz-range-thumb {\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range]::-ms-thumb {\n    opacity: 0.5;\n    width: 80px;\n    height: 80px;\n    background-color: black;\n    border:none;\n    border-radius: 5px;\n}\ninput[type=range][orient=vertical]{\n    writing-mode: bt-lr; /* IE */\n    -webkit-appearance: slider-vertical;  /* WebKit */\n}\n';
  var $mdgriffith$elm_ui$Internal$Style$trackReset = '\ninput[type=range]::-moz-range-track {\n    background: transparent;\n    cursor: pointer;\n}\ninput[type=range]::-ms-track {\n    background: transparent;\n    cursor: pointer;\n}\ninput[type=range]::-webkit-slider-runnable-track {\n    background: transparent;\n    cursor: pointer;\n}\n';
  var $mdgriffith$elm_ui$Internal$Style$overrides = '@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aX) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + (' { flex-basis: auto !important; } ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aX) + (' > ' + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.cQ) + ($mdgriffith$elm_ui$Internal$Style$dot($mdgriffith$elm_ui$Internal$Style$classes.aP) + (' { flex-basis: auto !important; }}' + ($mdgriffith$elm_ui$Internal$Style$inputTextReset + ($mdgriffith$elm_ui$Internal$Style$sliderReset + ($mdgriffith$elm_ui$Internal$Style$trackReset + ($mdgriffith$elm_ui$Internal$Style$thumbReset + $mdgriffith$elm_ui$Internal$Style$explainer)))))))))))))));
  var $elm$core$String$concat = function (strings) {
  	return A2($elm$core$String$join, '', strings);
  };
  var $mdgriffith$elm_ui$Internal$Style$Intermediate = $elm$core$Basics$identity;
  var $mdgriffith$elm_ui$Internal$Style$emptyIntermediate = F2(
  	function (selector, closing) {
  		return {aN: closing, n: _List_Nil, N: _List_Nil, E: selector};
  	});
  var $mdgriffith$elm_ui$Internal$Style$renderRules = F2(
  	function (_v0, rulesToRender) {
  		var parent = _v0;
  		var generateIntermediates = F2(
  			function (rule, rendered) {
  				switch (rule.$) {
  					case 0:
  						var name = rule.a;
  						var val = rule.b;
  						return _Utils_update(
  							rendered,
  							{
  								N: A2(
  									$elm$core$List$cons,
  									_Utils_Tuple2(name, val),
  									rendered.N)
  							});
  					case 2:
  						var _v2 = rule.a;
  						var prop = _v2.a;
  						var value = _v2.b;
  						var props = rule.b;
  						return _Utils_update(
  							rendered,
  							{
  								n: A2(
  									$elm$core$List$cons,
  									{aN: '\n}', n: _List_Nil, N: props, E: '@supports (' + (prop + (':' + (value + (') {' + parent.E))))},
  									rendered.n)
  							});
  					case 4:
  						var selector = rule.a;
  						var adjRules = rule.b;
  						return _Utils_update(
  							rendered,
  							{
  								n: A2(
  									$elm$core$List$cons,
  									A2(
  										$mdgriffith$elm_ui$Internal$Style$renderRules,
  										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.E + (' + ' + selector), ''),
  										adjRules),
  									rendered.n)
  							});
  					case 1:
  						var child = rule.a;
  						var childRules = rule.b;
  						return _Utils_update(
  							rendered,
  							{
  								n: A2(
  									$elm$core$List$cons,
  									A2(
  										$mdgriffith$elm_ui$Internal$Style$renderRules,
  										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.E + (' > ' + child), ''),
  										childRules),
  									rendered.n)
  							});
  					case 3:
  						var descriptor = rule.a;
  						var descriptorRules = rule.b;
  						return _Utils_update(
  							rendered,
  							{
  								n: A2(
  									$elm$core$List$cons,
  									A2(
  										$mdgriffith$elm_ui$Internal$Style$renderRules,
  										A2(
  											$mdgriffith$elm_ui$Internal$Style$emptyIntermediate,
  											_Utils_ap(parent.E, descriptor),
  											''),
  										descriptorRules),
  									rendered.n)
  							});
  					default:
  						var batched = rule.a;
  						return _Utils_update(
  							rendered,
  							{
  								n: A2(
  									$elm$core$List$cons,
  									A2(
  										$mdgriffith$elm_ui$Internal$Style$renderRules,
  										A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, parent.E, ''),
  										batched),
  									rendered.n)
  							});
  				}
  			});
  		return A3($elm$core$List$foldr, generateIntermediates, parent, rulesToRender);
  	});
  var $mdgriffith$elm_ui$Internal$Style$renderCompact = function (styleClasses) {
  	var renderValues = function (values) {
  		return $elm$core$String$concat(
  			A2(
  				$elm$core$List$map,
  				function (_v3) {
  					var x = _v3.a;
  					var y = _v3.b;
  					return x + (':' + (y + ';'));
  				},
  				values));
  	};
  	var renderClass = function (rule) {
  		var _v2 = rule.N;
  		if (!_v2.b) {
  			return '';
  		} else {
  			return rule.E + ('{' + (renderValues(rule.N) + (rule.aN + '}')));
  		}
  	};
  	var renderIntermediate = function (_v0) {
  		var rule = _v0;
  		return _Utils_ap(
  			renderClass(rule),
  			$elm$core$String$concat(
  				A2($elm$core$List$map, renderIntermediate, rule.n)));
  	};
  	return $elm$core$String$concat(
  		A2(
  			$elm$core$List$map,
  			renderIntermediate,
  			A3(
  				$elm$core$List$foldr,
  				F2(
  					function (_v1, existing) {
  						var name = _v1.a;
  						var styleRules = _v1.b;
  						return A2(
  							$elm$core$List$cons,
  							A2(
  								$mdgriffith$elm_ui$Internal$Style$renderRules,
  								A2($mdgriffith$elm_ui$Internal$Style$emptyIntermediate, name, ''),
  								styleRules),
  							existing);
  					}),
  				_List_Nil,
  				styleClasses)));
  };
  var $mdgriffith$elm_ui$Internal$Style$rules = _Utils_ap(
  	$mdgriffith$elm_ui$Internal$Style$overrides,
  	$mdgriffith$elm_ui$Internal$Style$renderCompact(
  		_Utils_ap($mdgriffith$elm_ui$Internal$Style$baseSheet, $mdgriffith$elm_ui$Internal$Style$commonValues)));
  var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;
  var $mdgriffith$elm_ui$Internal$Model$staticRoot = function (opts) {
  	var _v0 = opts.dJ;
  	switch (_v0) {
  		case 0:
  			return A3(
  				$elm$virtual_dom$VirtualDom$node,
  				'div',
  				_List_Nil,
  				_List_fromArray(
  					[
  						A3(
  						$elm$virtual_dom$VirtualDom$node,
  						'style',
  						_List_Nil,
  						_List_fromArray(
  							[
  								$elm$virtual_dom$VirtualDom$text($mdgriffith$elm_ui$Internal$Style$rules)
  							]))
  					]));
  		case 1:
  			return $elm$virtual_dom$VirtualDom$text('');
  		default:
  			return A3(
  				$elm$virtual_dom$VirtualDom$node,
  				'elm-ui-static-rules',
  				_List_fromArray(
  					[
  						A2(
  						$elm$virtual_dom$VirtualDom$property,
  						'rules',
  						$elm$json$Json$Encode$string($mdgriffith$elm_ui$Internal$Style$rules))
  					]),
  				_List_Nil);
  	}
  };
  var $elm$json$Json$Encode$object = function (pairs) {
  	return _Json_wrap(
  		A3(
  			$elm$core$List$foldl,
  			F2(
  				function (_v0, obj) {
  					var k = _v0.a;
  					var v = _v0.b;
  					return A3(_Json_addField, k, v, obj);
  				}),
  			_Json_emptyObject(0),
  			pairs));
  };
  var $mdgriffith$elm_ui$Internal$Model$fontName = function (font) {
  	switch (font.$) {
  		case 0:
  			return 'serif';
  		case 1:
  			return 'sans-serif';
  		case 2:
  			return 'monospace';
  		case 3:
  			var name = font.a;
  			return '\"' + (name + '\"');
  		case 4:
  			var name = font.a;
  			var url = font.b;
  			return '\"' + (name + '\"');
  		default:
  			var name = font.a.dK;
  			return '\"' + (name + '\"');
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$isSmallCaps = function (_var) {
  	switch (_var.$) {
  		case 0:
  			var name = _var.a;
  			return name === 'smcp';
  		case 1:
  			var name = _var.a;
  			return false;
  		default:
  			var name = _var.a;
  			var index = _var.b;
  			return (name === 'smcp') && (index === 1);
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$hasSmallCaps = function (typeface) {
  	if (typeface.$ === 5) {
  		var font = typeface.a;
  		return A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$isSmallCaps, font.cw);
  	} else {
  		return false;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$renderProps = F3(
  	function (force, _v0, existing) {
  		var key = _v0.a;
  		var val = _v0.b;
  		return force ? (existing + ('\n  ' + (key + (': ' + (val + ' !important;'))))) : (existing + ('\n  ' + (key + (': ' + (val + ';')))));
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderStyle = F4(
  	function (options, maybePseudo, selector, props) {
  		if (maybePseudo.$ === 1) {
  			return _List_fromArray(
  				[
  					selector + ('{' + (A3(
  					$elm$core$List$foldl,
  					$mdgriffith$elm_ui$Internal$Model$renderProps(false),
  					'',
  					props) + '\n}'))
  				]);
  		} else {
  			var pseudo = maybePseudo.a;
  			switch (pseudo) {
  				case 1:
  					var _v2 = options.dr;
  					switch (_v2) {
  						case 0:
  							return _List_Nil;
  						case 2:
  							return _List_fromArray(
  								[
  									selector + ('-hv {' + (A3(
  									$elm$core$List$foldl,
  									$mdgriffith$elm_ui$Internal$Model$renderProps(true),
  									'',
  									props) + '\n}'))
  								]);
  						default:
  							return _List_fromArray(
  								[
  									selector + ('-hv:hover {' + (A3(
  									$elm$core$List$foldl,
  									$mdgriffith$elm_ui$Internal$Model$renderProps(false),
  									'',
  									props) + '\n}'))
  								]);
  					}
  				case 0:
  					var renderedProps = A3(
  						$elm$core$List$foldl,
  						$mdgriffith$elm_ui$Internal$Model$renderProps(false),
  						'',
  						props);
  					return _List_fromArray(
  						[selector + ('-fs:focus {' + (renderedProps + '\n}')), '.' + ($mdgriffith$elm_ui$Internal$Style$classes.cQ + (':focus ~ ' + (selector + ('-fs:not(.focus)  {' + (renderedProps + '\n}'))))), '.' + ($mdgriffith$elm_ui$Internal$Style$classes.cQ + (':focus ' + (selector + ('-fs  {' + (renderedProps + '\n}'))))), selector + ('-fs:focus-within {' + (renderedProps + '\n}')), '.focusable-parent:focus ~ ' + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + (selector + ('-fs {' + (renderedProps + '\n}'))))))]);
  				default:
  					return _List_fromArray(
  						[
  							selector + ('-act:active {' + (A3(
  							$elm$core$List$foldl,
  							$mdgriffith$elm_ui$Internal$Model$renderProps(false),
  							'',
  							props) + '\n}'))
  						]);
  			}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderVariant = function (_var) {
  	switch (_var.$) {
  		case 0:
  			var name = _var.a;
  			return '\"' + (name + '\"');
  		case 1:
  			var name = _var.a;
  			return '\"' + (name + '\" 0');
  		default:
  			var name = _var.a;
  			var index = _var.b;
  			return '\"' + (name + ('\" ' + $elm$core$String$fromInt(index)));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$renderVariants = function (typeface) {
  	if (typeface.$ === 5) {
  		var font = typeface.a;
  		return $elm$core$Maybe$Just(
  			A2(
  				$elm$core$String$join,
  				', ',
  				A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$renderVariant, font.cw)));
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$transformValue = function (transform) {
  	switch (transform.$) {
  		case 0:
  			return $elm$core$Maybe$Nothing;
  		case 1:
  			var _v1 = transform.a;
  			var x = _v1.a;
  			var y = _v1.b;
  			var z = _v1.c;
  			return $elm$core$Maybe$Just(
  				'translate3d(' + ($elm$core$String$fromFloat(x) + ('px, ' + ($elm$core$String$fromFloat(y) + ('px, ' + ($elm$core$String$fromFloat(z) + 'px)'))))));
  		default:
  			var _v2 = transform.a;
  			var tx = _v2.a;
  			var ty = _v2.b;
  			var tz = _v2.c;
  			var _v3 = transform.b;
  			var sx = _v3.a;
  			var sy = _v3.b;
  			var sz = _v3.c;
  			var _v4 = transform.c;
  			var ox = _v4.a;
  			var oy = _v4.b;
  			var oz = _v4.c;
  			var angle = transform.d;
  			var translate = 'translate3d(' + ($elm$core$String$fromFloat(tx) + ('px, ' + ($elm$core$String$fromFloat(ty) + ('px, ' + ($elm$core$String$fromFloat(tz) + 'px)')))));
  			var scale = 'scale3d(' + ($elm$core$String$fromFloat(sx) + (', ' + ($elm$core$String$fromFloat(sy) + (', ' + ($elm$core$String$fromFloat(sz) + ')')))));
  			var rotate = 'rotate3d(' + ($elm$core$String$fromFloat(ox) + (', ' + ($elm$core$String$fromFloat(oy) + (', ' + ($elm$core$String$fromFloat(oz) + (', ' + ($elm$core$String$fromFloat(angle) + 'rad)')))))));
  			return $elm$core$Maybe$Just(translate + (' ' + (scale + (' ' + rotate))));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$renderStyleRule = F3(
  	function (options, rule, maybePseudo) {
  		switch (rule.$) {
  			case 0:
  				var selector = rule.a;
  				var props = rule.b;
  				return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, selector, props);
  			case 13:
  				var name = rule.a;
  				var prop = rule.b;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					'.' + name,
  					_List_fromArray(
  						[
  							A2($mdgriffith$elm_ui$Internal$Model$Property, 'box-shadow', prop)
  						]));
  			case 12:
  				var name = rule.a;
  				var transparency = rule.b;
  				var opacity = A2(
  					$elm$core$Basics$max,
  					0,
  					A2($elm$core$Basics$min, 1, 1 - transparency));
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					'.' + name,
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Model$Property,
  							'opacity',
  							$elm$core$String$fromFloat(opacity))
  						]));
  			case 2:
  				var i = rule.a;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					'.font-size-' + $elm$core$String$fromInt(i),
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Model$Property,
  							'font-size',
  							$elm$core$String$fromInt(i) + 'px')
  						]));
  			case 1:
  				var name = rule.a;
  				var typefaces = rule.b;
  				var features = A2(
  					$elm$core$String$join,
  					', ',
  					A2($elm$core$List$filterMap, $mdgriffith$elm_ui$Internal$Model$renderVariants, typefaces));
  				var families = _List_fromArray(
  					[
  						A2(
  						$mdgriffith$elm_ui$Internal$Model$Property,
  						'font-family',
  						A2(
  							$elm$core$String$join,
  							', ',
  							A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$fontName, typefaces))),
  						A2($mdgriffith$elm_ui$Internal$Model$Property, 'font-feature-settings', features),
  						A2(
  						$mdgriffith$elm_ui$Internal$Model$Property,
  						'font-variant',
  						A2($elm$core$List$any, $mdgriffith$elm_ui$Internal$Model$hasSmallCaps, typefaces) ? 'small-caps' : 'normal')
  					]);
  				return A4($mdgriffith$elm_ui$Internal$Model$renderStyle, options, maybePseudo, '.' + name, families);
  			case 3:
  				var _class = rule.a;
  				var prop = rule.b;
  				var val = rule.c;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					'.' + _class,
  					_List_fromArray(
  						[
  							A2($mdgriffith$elm_ui$Internal$Model$Property, prop, val)
  						]));
  			case 4:
  				var _class = rule.a;
  				var prop = rule.b;
  				var color = rule.c;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					'.' + _class,
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Model$Property,
  							prop,
  							$mdgriffith$elm_ui$Internal$Model$formatColor(color))
  						]));
  			case 5:
  				var cls = rule.a;
  				var x = rule.b;
  				var y = rule.c;
  				var yPx = $elm$core$String$fromInt(y) + 'px';
  				var xPx = $elm$core$String$fromInt(x) + 'px';
  				var single = '.' + $mdgriffith$elm_ui$Internal$Style$classes.d$;
  				var row = '.' + $mdgriffith$elm_ui$Internal$Style$classes.aX;
  				var wrappedRow = '.' + ($mdgriffith$elm_ui$Internal$Style$classes.bA + row);
  				var right = '.' + $mdgriffith$elm_ui$Internal$Style$classes.bD;
  				var paragraph = '.' + $mdgriffith$elm_ui$Internal$Style$classes.cb;
  				var page = '.' + $mdgriffith$elm_ui$Internal$Style$classes.ca;
  				var left = '.' + $mdgriffith$elm_ui$Internal$Style$classes.bC;
  				var halfY = $elm$core$String$fromFloat(y / 2) + 'px';
  				var halfX = $elm$core$String$fromFloat(x / 2) + 'px';
  				var column = '.' + $mdgriffith$elm_ui$Internal$Style$classes.I;
  				var _class = '.' + cls;
  				var any = '.' + $mdgriffith$elm_ui$Internal$Style$classes.cQ;
  				return $elm$core$List$concat(
  					_List_fromArray(
  						[
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (row + (' > ' + (any + (' + ' + any)))),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (wrappedRow + (' > ' + any)),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin', halfY + (' ' + halfX))
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (column + (' > ' + (any + (' + ' + any)))),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (page + (' > ' + (any + (' + ' + any)))),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-top', yPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (page + (' > ' + left)),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (page + (' > ' + right)),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_Utils_ap(_class, paragraph),
  							_List_fromArray(
  								[
  									A2(
  									$mdgriffith$elm_ui$Internal$Model$Property,
  									'line-height',
  									'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)'))
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							'textarea' + (any + _class),
  							_List_fromArray(
  								[
  									A2(
  									$mdgriffith$elm_ui$Internal$Model$Property,
  									'line-height',
  									'calc(1em + ' + ($elm$core$String$fromInt(y) + 'px)')),
  									A2(
  									$mdgriffith$elm_ui$Internal$Model$Property,
  									'height',
  									'calc(100% + ' + ($elm$core$String$fromInt(y) + 'px)'))
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (paragraph + (' > ' + left)),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-right', xPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (paragraph + (' > ' + right)),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'margin-left', xPx)
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (paragraph + '::after'),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'),
  									A2(
  									$mdgriffith$elm_ui$Internal$Model$Property,
  									'margin-top',
  									$elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px')
  								])),
  							A4(
  							$mdgriffith$elm_ui$Internal$Model$renderStyle,
  							options,
  							maybePseudo,
  							_class + (paragraph + '::before'),
  							_List_fromArray(
  								[
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'content', '\'\''),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'display', 'block'),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'height', '0'),
  									A2($mdgriffith$elm_ui$Internal$Model$Property, 'width', '0'),
  									A2(
  									$mdgriffith$elm_ui$Internal$Model$Property,
  									'margin-bottom',
  									$elm$core$String$fromInt((-1) * ((y / 2) | 0)) + 'px')
  								]))
  						]));
  			case 7:
  				var cls = rule.a;
  				var top = rule.b;
  				var right = rule.c;
  				var bottom = rule.d;
  				var left = rule.e;
  				var _class = '.' + cls;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					_class,
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Model$Property,
  							'padding',
  							$elm$core$String$fromInt(top) + ('px ' + ($elm$core$String$fromInt(right) + ('px ' + ($elm$core$String$fromInt(bottom) + ('px ' + ($elm$core$String$fromInt(left) + 'px')))))))
  						]));
  			case 6:
  				var cls = rule.a;
  				var top = rule.b;
  				var right = rule.c;
  				var bottom = rule.d;
  				var left = rule.e;
  				var _class = '.' + cls;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$renderStyle,
  					options,
  					maybePseudo,
  					_class,
  					_List_fromArray(
  						[
  							A2(
  							$mdgriffith$elm_ui$Internal$Model$Property,
  							'border-width',
  							$elm$core$String$fromInt(top) + ('px ' + ($elm$core$String$fromInt(right) + ('px ' + ($elm$core$String$fromInt(bottom) + ('px ' + ($elm$core$String$fromInt(left) + 'px')))))))
  						]));
  			case 8:
  				var template = rule.a;
  				var toGridLengthHelper = F3(
  					function (minimum, maximum, x) {
  						toGridLengthHelper:
  						while (true) {
  							switch (x.$) {
  								case 0:
  									var px = x.a;
  									return $elm$core$String$fromInt(px) + 'px';
  								case 1:
  									var _v2 = _Utils_Tuple2(minimum, maximum);
  									if (_v2.a.$ === 1) {
  										if (_v2.b.$ === 1) {
  											var _v3 = _v2.a;
  											var _v4 = _v2.b;
  											return 'max-content';
  										} else {
  											var _v6 = _v2.a;
  											var maxSize = _v2.b.a;
  											return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)');
  										}
  									} else {
  										if (_v2.b.$ === 1) {
  											var minSize = _v2.a.a;
  											var _v5 = _v2.b;
  											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + 'max-content)'));
  										} else {
  											var minSize = _v2.a.a;
  											var maxSize = _v2.b.a;
  											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)')));
  										}
  									}
  								case 2:
  									var i = x.a;
  									var _v7 = _Utils_Tuple2(minimum, maximum);
  									if (_v7.a.$ === 1) {
  										if (_v7.b.$ === 1) {
  											var _v8 = _v7.a;
  											var _v9 = _v7.b;
  											return $elm$core$String$fromInt(i) + 'fr';
  										} else {
  											var _v11 = _v7.a;
  											var maxSize = _v7.b.a;
  											return 'minmax(max-content, ' + ($elm$core$String$fromInt(maxSize) + 'px)');
  										}
  									} else {
  										if (_v7.b.$ === 1) {
  											var minSize = _v7.a.a;
  											var _v10 = _v7.b;
  											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(i) + ('fr' + 'fr)'))));
  										} else {
  											var minSize = _v7.a.a;
  											var maxSize = _v7.b.a;
  											return 'minmax(' + ($elm$core$String$fromInt(minSize) + ('px, ' + ($elm$core$String$fromInt(maxSize) + 'px)')));
  										}
  									}
  								case 3:
  									var m = x.a;
  									var len = x.b;
  									var $temp$minimum = $elm$core$Maybe$Just(m),
  										$temp$maximum = maximum,
  										$temp$x = len;
  									minimum = $temp$minimum;
  									maximum = $temp$maximum;
  									x = $temp$x;
  									continue toGridLengthHelper;
  								default:
  									var m = x.a;
  									var len = x.b;
  									var $temp$minimum = minimum,
  										$temp$maximum = $elm$core$Maybe$Just(m),
  										$temp$x = len;
  									minimum = $temp$minimum;
  									maximum = $temp$maximum;
  									x = $temp$x;
  									continue toGridLengthHelper;
  							}
  						}
  					});
  				var toGridLength = function (x) {
  					return A3(toGridLengthHelper, $elm$core$Maybe$Nothing, $elm$core$Maybe$Nothing, x);
  				};
  				var xSpacing = toGridLength(template.d2.a);
  				var ySpacing = toGridLength(template.d2.b);
  				var rows = function (x) {
  					return 'grid-template-rows: ' + (x + ';');
  				}(
  					A2(
  						$elm$core$String$join,
  						' ',
  						A2($elm$core$List$map, toGridLength, template.dV)));
  				var msRows = function (x) {
  					return '-ms-grid-rows: ' + (x + ';');
  				}(
  					A2(
  						$elm$core$String$join,
  						ySpacing,
  						A2($elm$core$List$map, toGridLength, template.bb)));
  				var msColumns = function (x) {
  					return '-ms-grid-columns: ' + (x + ';');
  				}(
  					A2(
  						$elm$core$String$join,
  						ySpacing,
  						A2($elm$core$List$map, toGridLength, template.bb)));
  				var gapY = 'grid-row-gap:' + (toGridLength(template.d2.b) + ';');
  				var gapX = 'grid-column-gap:' + (toGridLength(template.d2.a) + ';');
  				var columns = function (x) {
  					return 'grid-template-columns: ' + (x + ';');
  				}(
  					A2(
  						$elm$core$String$join,
  						' ',
  						A2($elm$core$List$map, toGridLength, template.bb)));
  				var _class = '.grid-rows-' + (A2(
  					$elm$core$String$join,
  					'-',
  					A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.dV)) + ('-cols-' + (A2(
  					$elm$core$String$join,
  					'-',
  					A2($elm$core$List$map, $mdgriffith$elm_ui$Internal$Model$lengthClassName, template.bb)) + ('-space-x-' + ($mdgriffith$elm_ui$Internal$Model$lengthClassName(template.d2.a) + ('-space-y-' + $mdgriffith$elm_ui$Internal$Model$lengthClassName(template.d2.b)))))));
  				var modernGrid = _class + ('{' + (columns + (rows + (gapX + (gapY + '}')))));
  				var supports = '@supports (display:grid) {' + (modernGrid + '}');
  				var base = _class + ('{' + (msColumns + (msRows + '}')));
  				return _List_fromArray(
  					[base, supports]);
  			case 9:
  				var position = rule.a;
  				var msPosition = A2(
  					$elm$core$String$join,
  					' ',
  					_List_fromArray(
  						[
  							'-ms-grid-row: ' + ($elm$core$String$fromInt(position.aX) + ';'),
  							'-ms-grid-row-span: ' + ($elm$core$String$fromInt(position.bS) + ';'),
  							'-ms-grid-column: ' + ($elm$core$String$fromInt(position.aO) + ';'),
  							'-ms-grid-column-span: ' + ($elm$core$String$fromInt(position.aJ) + ';')
  						]));
  				var modernPosition = A2(
  					$elm$core$String$join,
  					' ',
  					_List_fromArray(
  						[
  							'grid-row: ' + ($elm$core$String$fromInt(position.aX) + (' / ' + ($elm$core$String$fromInt(position.aX + position.bS) + ';'))),
  							'grid-column: ' + ($elm$core$String$fromInt(position.aO) + (' / ' + ($elm$core$String$fromInt(position.aO + position.aJ) + ';')))
  						]));
  				var _class = '.grid-pos-' + ($elm$core$String$fromInt(position.aX) + ('-' + ($elm$core$String$fromInt(position.aO) + ('-' + ($elm$core$String$fromInt(position.aJ) + ('-' + $elm$core$String$fromInt(position.bS)))))));
  				var modernGrid = _class + ('{' + (modernPosition + '}'));
  				var supports = '@supports (display:grid) {' + (modernGrid + '}');
  				var base = _class + ('{' + (msPosition + '}'));
  				return _List_fromArray(
  					[base, supports]);
  			case 11:
  				var _class = rule.a;
  				var styles = rule.b;
  				var renderPseudoRule = function (style) {
  					return A3(
  						$mdgriffith$elm_ui$Internal$Model$renderStyleRule,
  						options,
  						style,
  						$elm$core$Maybe$Just(_class));
  				};
  				return A2($elm$core$List$concatMap, renderPseudoRule, styles);
  			default:
  				var transform = rule.a;
  				var val = $mdgriffith$elm_ui$Internal$Model$transformValue(transform);
  				var _class = $mdgriffith$elm_ui$Internal$Model$transformClass(transform);
  				var _v12 = _Utils_Tuple2(_class, val);
  				if ((!_v12.a.$) && (!_v12.b.$)) {
  					var cls = _v12.a.a;
  					var v = _v12.b.a;
  					return A4(
  						$mdgriffith$elm_ui$Internal$Model$renderStyle,
  						options,
  						maybePseudo,
  						'.' + cls,
  						_List_fromArray(
  							[
  								A2($mdgriffith$elm_ui$Internal$Model$Property, 'transform', v)
  							]));
  				} else {
  					return _List_Nil;
  				}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$encodeStyles = F2(
  	function (options, stylesheet) {
  		return $elm$json$Json$Encode$object(
  			A2(
  				$elm$core$List$map,
  				function (style) {
  					var styled = A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing);
  					return _Utils_Tuple2(
  						$mdgriffith$elm_ui$Internal$Model$getStyleName(style),
  						A2($elm$json$Json$Encode$list, $elm$json$Json$Encode$string, styled));
  				},
  				stylesheet));
  	});
  var $mdgriffith$elm_ui$Internal$Model$bracket = F2(
  	function (selector, rules) {
  		var renderPair = function (_v0) {
  			var name = _v0.a;
  			var val = _v0.b;
  			return name + (': ' + (val + ';'));
  		};
  		return selector + (' {' + (A2(
  			$elm$core$String$join,
  			'',
  			A2($elm$core$List$map, renderPair, rules)) + '}'));
  	});
  var $mdgriffith$elm_ui$Internal$Model$fontRule = F3(
  	function (name, modifier, _v0) {
  		var parentAdj = _v0.a;
  		var textAdjustment = _v0.b;
  		return _List_fromArray(
  			[
  				A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + (', ' + ('.' + (name + (' .' + modifier))))))), parentAdj),
  				A2($mdgriffith$elm_ui$Internal$Model$bracket, '.' + (name + ('.' + (modifier + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.ct + (', .' + (name + (' .' + (modifier + (' > .' + $mdgriffith$elm_ui$Internal$Style$classes.ct)))))))))), textAdjustment)
  			]);
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule = F3(
  	function (fontToAdjust, _v0, otherFontName) {
  		var full = _v0.a;
  		var capital = _v0.b;
  		var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust));
  		return A2(
  			$elm$core$String$join,
  			' ',
  			_Utils_ap(
  				A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.d0, capital),
  				A3($mdgriffith$elm_ui$Internal$Model$fontRule, name, $mdgriffith$elm_ui$Internal$Style$classes.dn, full)));
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule = F2(
  	function (fontToAdjust, otherFontName) {
  		var name = _Utils_eq(fontToAdjust, otherFontName) ? fontToAdjust : (otherFontName + (' .' + fontToAdjust));
  		return A2(
  			$elm$core$String$join,
  			' ',
  			_List_fromArray(
  				[
  					A2(
  					$mdgriffith$elm_ui$Internal$Model$bracket,
  					'.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.d0 + (', ' + ('.' + (name + (' .' + $mdgriffith$elm_ui$Internal$Style$classes.d0))))))),
  					_List_fromArray(
  						[
  							_Utils_Tuple2('line-height', '1')
  						])),
  					A2(
  					$mdgriffith$elm_ui$Internal$Model$bracket,
  					'.' + (name + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.d0 + ('> .' + ($mdgriffith$elm_ui$Internal$Style$classes.ct + (', .' + (name + (' .' + ($mdgriffith$elm_ui$Internal$Style$classes.d0 + (' > .' + $mdgriffith$elm_ui$Internal$Style$classes.ct)))))))))),
  					_List_fromArray(
  						[
  							_Utils_Tuple2('vertical-align', '0'),
  							_Utils_Tuple2('line-height', '1')
  						]))
  				]));
  	});
  var $mdgriffith$elm_ui$Internal$Model$adjust = F3(
  	function (size, height, vertical) {
  		return {bS: height / size, aZ: size, cx: vertical};
  	});
  var $elm$core$List$maximum = function (list) {
  	if (list.b) {
  		var x = list.a;
  		var xs = list.b;
  		return $elm$core$Maybe$Just(
  			A3($elm$core$List$foldl, $elm$core$Basics$max, x, xs));
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $elm$core$List$minimum = function (list) {
  	if (list.b) {
  		var x = list.a;
  		var xs = list.b;
  		return $elm$core$Maybe$Just(
  			A3($elm$core$List$foldl, $elm$core$Basics$min, x, xs));
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$convertAdjustment = function (adjustment) {
  	var lines = _List_fromArray(
  		[adjustment.c3, adjustment.cT, adjustment.de, adjustment.dG]);
  	var lineHeight = 1.5;
  	var normalDescender = (lineHeight - 1) / 2;
  	var oldMiddle = lineHeight / 2;
  	var descender = A2(
  		$elm$core$Maybe$withDefault,
  		adjustment.de,
  		$elm$core$List$minimum(lines));
  	var newBaseline = A2(
  		$elm$core$Maybe$withDefault,
  		adjustment.cT,
  		$elm$core$List$minimum(
  			A2(
  				$elm$core$List$filter,
  				function (x) {
  					return !_Utils_eq(x, descender);
  				},
  				lines)));
  	var base = lineHeight;
  	var ascender = A2(
  		$elm$core$Maybe$withDefault,
  		adjustment.c3,
  		$elm$core$List$maximum(lines));
  	var capitalSize = 1 / (ascender - newBaseline);
  	var capitalVertical = 1 - ascender;
  	var fullSize = 1 / (ascender - descender);
  	var fullVertical = 1 - ascender;
  	var newCapitalMiddle = ((ascender - newBaseline) / 2) + newBaseline;
  	var newFullMiddle = ((ascender - descender) / 2) + descender;
  	return {
  		c3: A3($mdgriffith$elm_ui$Internal$Model$adjust, capitalSize, ascender - newBaseline, capitalVertical),
  		bR: A3($mdgriffith$elm_ui$Internal$Model$adjust, fullSize, ascender - descender, fullVertical)
  	};
  };
  var $mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules = function (converted) {
  	return _Utils_Tuple2(
  		_List_fromArray(
  			[
  				_Utils_Tuple2('display', 'block')
  			]),
  		_List_fromArray(
  			[
  				_Utils_Tuple2('display', 'inline-block'),
  				_Utils_Tuple2(
  				'line-height',
  				$elm$core$String$fromFloat(converted.bS)),
  				_Utils_Tuple2(
  				'vertical-align',
  				$elm$core$String$fromFloat(converted.cx) + 'em'),
  				_Utils_Tuple2(
  				'font-size',
  				$elm$core$String$fromFloat(converted.aZ) + 'em')
  			]));
  };
  var $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment = function (typefaces) {
  	return A3(
  		$elm$core$List$foldl,
  		F2(
  			function (face, found) {
  				if (found.$ === 1) {
  					if (face.$ === 5) {
  						var _with = face.a;
  						var _v2 = _with.cG;
  						if (_v2.$ === 1) {
  							return found;
  						} else {
  							var adjustment = _v2.a;
  							return $elm$core$Maybe$Just(
  								_Utils_Tuple2(
  									$mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules(
  										function ($) {
  											return $.bR;
  										}(
  											$mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment))),
  									$mdgriffith$elm_ui$Internal$Model$fontAdjustmentRules(
  										function ($) {
  											return $.c3;
  										}(
  											$mdgriffith$elm_ui$Internal$Model$convertAdjustment(adjustment)))));
  						}
  					} else {
  						return found;
  					}
  				} else {
  					return found;
  				}
  			}),
  		$elm$core$Maybe$Nothing,
  		typefaces);
  };
  var $mdgriffith$elm_ui$Internal$Model$renderTopLevelValues = function (rules) {
  	var withImport = function (font) {
  		if (font.$ === 4) {
  			var url = font.b;
  			return $elm$core$Maybe$Just('@import url(\'' + (url + '\');'));
  		} else {
  			return $elm$core$Maybe$Nothing;
  		}
  	};
  	var fontImports = function (_v2) {
  		var name = _v2.a;
  		var typefaces = _v2.b;
  		var imports = A2(
  			$elm$core$String$join,
  			'\n',
  			A2($elm$core$List$filterMap, withImport, typefaces));
  		return imports;
  	};
  	var allNames = A2($elm$core$List$map, $elm$core$Tuple$first, rules);
  	var fontAdjustments = function (_v1) {
  		var name = _v1.a;
  		var typefaces = _v1.b;
  		var _v0 = $mdgriffith$elm_ui$Internal$Model$typefaceAdjustment(typefaces);
  		if (_v0.$ === 1) {
  			return A2(
  				$elm$core$String$join,
  				'',
  				A2(
  					$elm$core$List$map,
  					$mdgriffith$elm_ui$Internal$Model$renderNullAdjustmentRule(name),
  					allNames));
  		} else {
  			var adjustment = _v0.a;
  			return A2(
  				$elm$core$String$join,
  				'',
  				A2(
  					$elm$core$List$map,
  					A2($mdgriffith$elm_ui$Internal$Model$renderFontAdjustmentRule, name, adjustment),
  					allNames));
  		}
  	};
  	return _Utils_ap(
  		A2(
  			$elm$core$String$join,
  			'\n',
  			A2($elm$core$List$map, fontImports, rules)),
  		A2(
  			$elm$core$String$join,
  			'\n',
  			A2($elm$core$List$map, fontAdjustments, rules)));
  };
  var $mdgriffith$elm_ui$Internal$Model$topLevelValue = function (rule) {
  	if (rule.$ === 1) {
  		var name = rule.a;
  		var typefaces = rule.b;
  		return $elm$core$Maybe$Just(
  			_Utils_Tuple2(name, typefaces));
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$toStyleSheetString = F2(
  	function (options, stylesheet) {
  		var combine = F2(
  			function (style, rendered) {
  				return {
  					aY: _Utils_ap(
  						rendered.aY,
  						A3($mdgriffith$elm_ui$Internal$Model$renderStyleRule, options, style, $elm$core$Maybe$Nothing)),
  					aG: function () {
  						var _v1 = $mdgriffith$elm_ui$Internal$Model$topLevelValue(style);
  						if (_v1.$ === 1) {
  							return rendered.aG;
  						} else {
  							var topLevel = _v1.a;
  							return A2($elm$core$List$cons, topLevel, rendered.aG);
  						}
  					}()
  				};
  			});
  		var _v0 = A3(
  			$elm$core$List$foldl,
  			combine,
  			{aY: _List_Nil, aG: _List_Nil},
  			stylesheet);
  		var topLevel = _v0.aG;
  		var rules = _v0.aY;
  		return _Utils_ap(
  			$mdgriffith$elm_ui$Internal$Model$renderTopLevelValues(topLevel),
  			$elm$core$String$concat(rules));
  	});
  var $mdgriffith$elm_ui$Internal$Model$toStyleSheet = F2(
  	function (options, styleSheet) {
  		var _v0 = options.dJ;
  		switch (_v0) {
  			case 0:
  				return A3(
  					$elm$virtual_dom$VirtualDom$node,
  					'div',
  					_List_Nil,
  					_List_fromArray(
  						[
  							A3(
  							$elm$virtual_dom$VirtualDom$node,
  							'style',
  							_List_Nil,
  							_List_fromArray(
  								[
  									$elm$virtual_dom$VirtualDom$text(
  									A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet))
  								]))
  						]));
  			case 1:
  				return A3(
  					$elm$virtual_dom$VirtualDom$node,
  					'div',
  					_List_Nil,
  					_List_fromArray(
  						[
  							A3(
  							$elm$virtual_dom$VirtualDom$node,
  							'style',
  							_List_Nil,
  							_List_fromArray(
  								[
  									$elm$virtual_dom$VirtualDom$text(
  									A2($mdgriffith$elm_ui$Internal$Model$toStyleSheetString, options, styleSheet))
  								]))
  						]));
  			default:
  				return A3(
  					$elm$virtual_dom$VirtualDom$node,
  					'elm-ui-rules',
  					_List_fromArray(
  						[
  							A2(
  							$elm$virtual_dom$VirtualDom$property,
  							'rules',
  							A2($mdgriffith$elm_ui$Internal$Model$encodeStyles, options, styleSheet))
  						]),
  					_List_Nil);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$embedKeyed = F4(
  	function (_static, opts, styles, children) {
  		var dynamicStyleSheet = A2(
  			$mdgriffith$elm_ui$Internal$Model$toStyleSheet,
  			opts,
  			A3(
  				$elm$core$List$foldl,
  				$mdgriffith$elm_ui$Internal$Model$reduceStyles,
  				_Utils_Tuple2(
  					$elm$core$Set$empty,
  					$mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.dm)),
  				styles).b);
  		return _static ? A2(
  			$elm$core$List$cons,
  			_Utils_Tuple2(
  				'static-stylesheet',
  				$mdgriffith$elm_ui$Internal$Model$staticRoot(opts)),
  			A2(
  				$elm$core$List$cons,
  				_Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet),
  				children)) : A2(
  			$elm$core$List$cons,
  			_Utils_Tuple2('dynamic-stylesheet', dynamicStyleSheet),
  			children);
  	});
  var $mdgriffith$elm_ui$Internal$Model$embedWith = F4(
  	function (_static, opts, styles, children) {
  		var dynamicStyleSheet = A2(
  			$mdgriffith$elm_ui$Internal$Model$toStyleSheet,
  			opts,
  			A3(
  				$elm$core$List$foldl,
  				$mdgriffith$elm_ui$Internal$Model$reduceStyles,
  				_Utils_Tuple2(
  					$elm$core$Set$empty,
  					$mdgriffith$elm_ui$Internal$Model$renderFocusStyle(opts.dm)),
  				styles).b);
  		return _static ? A2(
  			$elm$core$List$cons,
  			$mdgriffith$elm_ui$Internal$Model$staticRoot(opts),
  			A2($elm$core$List$cons, dynamicStyleSheet, children)) : A2($elm$core$List$cons, dynamicStyleSheet, children);
  	});
  var $mdgriffith$elm_ui$Internal$Flag$heightBetween = $mdgriffith$elm_ui$Internal$Flag$flag(45);
  var $mdgriffith$elm_ui$Internal$Flag$heightFill = $mdgriffith$elm_ui$Internal$Flag$flag(37);
  var $elm$virtual_dom$VirtualDom$keyedNode = function (tag) {
  	return _VirtualDom_keyedNode(
  		_VirtualDom_noScript(tag));
  };
  var $elm$html$Html$p = _VirtualDom_node('p');
  var $mdgriffith$elm_ui$Internal$Flag$present = F2(
  	function (myFlag, _v0) {
  		var fieldOne = _v0.a;
  		var fieldTwo = _v0.b;
  		if (!myFlag.$) {
  			var first = myFlag.a;
  			return _Utils_eq(first & fieldOne, first);
  		} else {
  			var second = myFlag.a;
  			return _Utils_eq(second & fieldTwo, second);
  		}
  	});
  var $elm$html$Html$s = _VirtualDom_node('s');
  var $elm$html$Html$u = _VirtualDom_node('u');
  var $mdgriffith$elm_ui$Internal$Flag$widthBetween = $mdgriffith$elm_ui$Internal$Flag$flag(44);
  var $mdgriffith$elm_ui$Internal$Flag$widthFill = $mdgriffith$elm_ui$Internal$Flag$flag(39);
  var $mdgriffith$elm_ui$Internal$Model$finalizeNode = F6(
  	function (has, node, attributes, children, embedMode, parentContext) {
  		var createNode = F2(
  			function (nodeName, attrs) {
  				if (children.$ === 1) {
  					var keyed = children.a;
  					return A3(
  						$elm$virtual_dom$VirtualDom$keyedNode,
  						nodeName,
  						attrs,
  						function () {
  							switch (embedMode.$) {
  								case 0:
  									return keyed;
  								case 2:
  									var opts = embedMode.a;
  									var styles = embedMode.b;
  									return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, false, opts, styles, keyed);
  								default:
  									var opts = embedMode.a;
  									var styles = embedMode.b;
  									return A4($mdgriffith$elm_ui$Internal$Model$embedKeyed, true, opts, styles, keyed);
  							}
  						}());
  				} else {
  					var unkeyed = children.a;
  					return A2(
  						function () {
  							switch (nodeName) {
  								case 'div':
  									return $elm$html$Html$div;
  								case 'p':
  									return $elm$html$Html$p;
  								default:
  									return $elm$virtual_dom$VirtualDom$node(nodeName);
  							}
  						}(),
  						attrs,
  						function () {
  							switch (embedMode.$) {
  								case 0:
  									return unkeyed;
  								case 2:
  									var opts = embedMode.a;
  									var styles = embedMode.b;
  									return A4($mdgriffith$elm_ui$Internal$Model$embedWith, false, opts, styles, unkeyed);
  								default:
  									var opts = embedMode.a;
  									var styles = embedMode.b;
  									return A4($mdgriffith$elm_ui$Internal$Model$embedWith, true, opts, styles, unkeyed);
  							}
  						}());
  				}
  			});
  		var html = function () {
  			switch (node.$) {
  				case 0:
  					return A2(createNode, 'div', attributes);
  				case 1:
  					var nodeName = node.a;
  					return A2(createNode, nodeName, attributes);
  				default:
  					var nodeName = node.a;
  					var internal = node.b;
  					return A3(
  						$elm$virtual_dom$VirtualDom$node,
  						nodeName,
  						attributes,
  						_List_fromArray(
  							[
  								A2(
  								createNode,
  								internal,
  								_List_fromArray(
  									[
  										$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.d$))
  									]))
  							]));
  			}
  		}();
  		switch (parentContext) {
  			case 0:
  				return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$widthBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignRight, has) ? A2(
  					$elm$html$Html$u,
  					_List_fromArray(
  						[
  							$elm$html$Html$Attributes$class(
  							A2(
  								$elm$core$String$join,
  								' ',
  								_List_fromArray(
  									[$mdgriffith$elm_ui$Internal$Style$classes.cQ, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.aP, $mdgriffith$elm_ui$Internal$Style$classes.J, $mdgriffith$elm_ui$Internal$Style$classes.cN])))
  						]),
  					_List_fromArray(
  						[html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerX, has) ? A2(
  					$elm$html$Html$s,
  					_List_fromArray(
  						[
  							$elm$html$Html$Attributes$class(
  							A2(
  								$elm$core$String$join,
  								' ',
  								_List_fromArray(
  									[$mdgriffith$elm_ui$Internal$Style$classes.cQ, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.aP, $mdgriffith$elm_ui$Internal$Style$classes.J, $mdgriffith$elm_ui$Internal$Style$classes.cL])))
  						]),
  					_List_fromArray(
  						[html])) : html));
  			case 1:
  				return (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightFill, has) && (!A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$heightBetween, has))) ? html : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$centerY, has) ? A2(
  					$elm$html$Html$s,
  					_List_fromArray(
  						[
  							$elm$html$Html$Attributes$class(
  							A2(
  								$elm$core$String$join,
  								' ',
  								_List_fromArray(
  									[$mdgriffith$elm_ui$Internal$Style$classes.cQ, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.aP, $mdgriffith$elm_ui$Internal$Style$classes.cM])))
  						]),
  					_List_fromArray(
  						[html])) : (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$alignBottom, has) ? A2(
  					$elm$html$Html$u,
  					_List_fromArray(
  						[
  							$elm$html$Html$Attributes$class(
  							A2(
  								$elm$core$String$join,
  								' ',
  								_List_fromArray(
  									[$mdgriffith$elm_ui$Internal$Style$classes.cQ, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.aP, $mdgriffith$elm_ui$Internal$Style$classes.cK])))
  						]),
  					_List_fromArray(
  						[html])) : html));
  			default:
  				return html;
  		}
  	});
  var $elm$core$List$isEmpty = function (xs) {
  	if (!xs.b) {
  		return true;
  	} else {
  		return false;
  	}
  };
  var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;
  var $mdgriffith$elm_ui$Internal$Model$textElementClasses = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ct + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.by + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.bh)))));
  var $mdgriffith$elm_ui$Internal$Model$textElement = function (str) {
  	return A2(
  		$elm$html$Html$div,
  		_List_fromArray(
  			[
  				$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementClasses)
  			]),
  		_List_fromArray(
  			[
  				$elm$html$Html$text(str)
  			]));
  };
  var $mdgriffith$elm_ui$Internal$Model$textElementFillClasses = $mdgriffith$elm_ui$Internal$Style$classes.cQ + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.ct + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.bz + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.bi)))));
  var $mdgriffith$elm_ui$Internal$Model$textElementFill = function (str) {
  	return A2(
  		$elm$html$Html$div,
  		_List_fromArray(
  			[
  				$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Model$textElementFillClasses)
  			]),
  		_List_fromArray(
  			[
  				$elm$html$Html$text(str)
  			]));
  };
  var $mdgriffith$elm_ui$Internal$Model$createElement = F3(
  	function (context, children, rendered) {
  		var gatherKeyed = F2(
  			function (_v8, _v9) {
  				var key = _v8.a;
  				var child = _v8.b;
  				var htmls = _v9.a;
  				var existingStyles = _v9.b;
  				switch (child.$) {
  					case 0:
  						var html = child.a;
  						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									key,
  									html(context)),
  								htmls),
  							existingStyles) : _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									key,
  									html(context)),
  								htmls),
  							existingStyles);
  					case 1:
  						var styled = child.a;
  						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									key,
  									A2(styled.ds, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)),
  								htmls),
  							$elm$core$List$isEmpty(existingStyles) ? styled.d7 : _Utils_ap(styled.d7, existingStyles)) : _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									key,
  									A2(styled.ds, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context)),
  								htmls),
  							$elm$core$List$isEmpty(existingStyles) ? styled.d7 : _Utils_ap(styled.d7, existingStyles));
  					case 2:
  						var str = child.a;
  						return _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_Tuple2(
  									key,
  									_Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) : $mdgriffith$elm_ui$Internal$Model$textElement(str)),
  								htmls),
  							existingStyles);
  					default:
  						return _Utils_Tuple2(htmls, existingStyles);
  				}
  			});
  		var gather = F2(
  			function (child, _v6) {
  				var htmls = _v6.a;
  				var existingStyles = _v6.b;
  				switch (child.$) {
  					case 0:
  						var html = child.a;
  						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								html(context),
  								htmls),
  							existingStyles) : _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								html(context),
  								htmls),
  							existingStyles);
  					case 1:
  						var styled = child.a;
  						return _Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asParagraph) ? _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								A2(styled.ds, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context),
  								htmls),
  							$elm$core$List$isEmpty(existingStyles) ? styled.d7 : _Utils_ap(styled.d7, existingStyles)) : _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								A2(styled.ds, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, context),
  								htmls),
  							$elm$core$List$isEmpty(existingStyles) ? styled.d7 : _Utils_ap(styled.d7, existingStyles));
  					case 2:
  						var str = child.a;
  						return _Utils_Tuple2(
  							A2(
  								$elm$core$List$cons,
  								_Utils_eq(context, $mdgriffith$elm_ui$Internal$Model$asEl) ? $mdgriffith$elm_ui$Internal$Model$textElementFill(str) : $mdgriffith$elm_ui$Internal$Model$textElement(str),
  								htmls),
  							existingStyles);
  					default:
  						return _Utils_Tuple2(htmls, existingStyles);
  				}
  			});
  		if (children.$ === 1) {
  			var keyedChildren = children.a;
  			var _v1 = A3(
  				$elm$core$List$foldr,
  				gatherKeyed,
  				_Utils_Tuple2(_List_Nil, _List_Nil),
  				keyedChildren);
  			var keyed = _v1.a;
  			var styles = _v1.b;
  			var newStyles = $elm$core$List$isEmpty(styles) ? rendered.d7 : _Utils_ap(rendered.d7, styles);
  			if (!newStyles.b) {
  				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
  					A5(
  						$mdgriffith$elm_ui$Internal$Model$finalizeNode,
  						rendered.U,
  						rendered.Y,
  						rendered.R,
  						$mdgriffith$elm_ui$Internal$Model$Keyed(
  							A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.S)),
  						$mdgriffith$elm_ui$Internal$Model$NoStyleSheet));
  			} else {
  				var allStyles = newStyles;
  				return $mdgriffith$elm_ui$Internal$Model$Styled(
  					{
  						ds: A4(
  							$mdgriffith$elm_ui$Internal$Model$finalizeNode,
  							rendered.U,
  							rendered.Y,
  							rendered.R,
  							$mdgriffith$elm_ui$Internal$Model$Keyed(
  								A3($mdgriffith$elm_ui$Internal$Model$addKeyedChildren, 'nearby-element-pls', keyed, rendered.S))),
  						d7: allStyles
  					});
  			}
  		} else {
  			var unkeyedChildren = children.a;
  			var _v3 = A3(
  				$elm$core$List$foldr,
  				gather,
  				_Utils_Tuple2(_List_Nil, _List_Nil),
  				unkeyedChildren);
  			var unkeyed = _v3.a;
  			var styles = _v3.b;
  			var newStyles = $elm$core$List$isEmpty(styles) ? rendered.d7 : _Utils_ap(rendered.d7, styles);
  			if (!newStyles.b) {
  				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
  					A5(
  						$mdgriffith$elm_ui$Internal$Model$finalizeNode,
  						rendered.U,
  						rendered.Y,
  						rendered.R,
  						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  							A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.S)),
  						$mdgriffith$elm_ui$Internal$Model$NoStyleSheet));
  			} else {
  				var allStyles = newStyles;
  				return $mdgriffith$elm_ui$Internal$Model$Styled(
  					{
  						ds: A4(
  							$mdgriffith$elm_ui$Internal$Model$finalizeNode,
  							rendered.U,
  							rendered.Y,
  							rendered.R,
  							$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  								A2($mdgriffith$elm_ui$Internal$Model$addChildren, unkeyed, rendered.S))),
  						d7: allStyles
  					});
  			}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$Single = F3(
  	function (a, b, c) {
  		return {$: 3, a: a, b: b, c: c};
  	});
  var $mdgriffith$elm_ui$Internal$Model$Transform = function (a) {
  	return {$: 10, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Flag$Field = F2(
  	function (a, b) {
  		return {$: 0, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$add = F2(
  	function (myFlag, _v0) {
  		var one = _v0.a;
  		var two = _v0.b;
  		if (!myFlag.$) {
  			var first = myFlag.a;
  			return A2($mdgriffith$elm_ui$Internal$Flag$Field, first | one, two);
  		} else {
  			var second = myFlag.a;
  			return A2($mdgriffith$elm_ui$Internal$Flag$Field, one, second | two);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$ChildrenBehind = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront = F2(
  	function (a, b) {
  		return {$: 3, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$ChildrenInFront = function (a) {
  	return {$: 2, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$nearbyElement = F2(
  	function (location, elem) {
  		return A2(
  			$elm$html$Html$div,
  			_List_fromArray(
  				[
  					$elm$html$Html$Attributes$class(
  					function () {
  						switch (location) {
  							case 0:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.cF]));
  							case 1:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.cV]));
  							case 2:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.dM]));
  							case 3:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.dL]));
  							case 4:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.dv]));
  							default:
  								return A2(
  									$elm$core$String$join,
  									' ',
  									_List_fromArray(
  										[$mdgriffith$elm_ui$Internal$Style$classes.ak, $mdgriffith$elm_ui$Internal$Style$classes.d$, $mdgriffith$elm_ui$Internal$Style$classes.cU]));
  						}
  					}())
  				]),
  			_List_fromArray(
  				[
  					function () {
  					switch (elem.$) {
  						case 3:
  							return $elm$virtual_dom$VirtualDom$text('');
  						case 2:
  							var str = elem.a;
  							return $mdgriffith$elm_ui$Internal$Model$textElement(str);
  						case 0:
  							var html = elem.a;
  							return html($mdgriffith$elm_ui$Internal$Model$asEl);
  						default:
  							var styled = elem.a;
  							return A2(styled.ds, $mdgriffith$elm_ui$Internal$Model$NoStyleSheet, $mdgriffith$elm_ui$Internal$Model$asEl);
  					}
  				}()
  				]));
  	});
  var $mdgriffith$elm_ui$Internal$Model$addNearbyElement = F3(
  	function (location, elem, existing) {
  		var nearby = A2($mdgriffith$elm_ui$Internal$Model$nearbyElement, location, elem);
  		switch (existing.$) {
  			case 0:
  				if (location === 5) {
  					return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind(
  						_List_fromArray(
  							[nearby]));
  				} else {
  					return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront(
  						_List_fromArray(
  							[nearby]));
  				}
  			case 1:
  				var existingBehind = existing.a;
  				if (location === 5) {
  					return $mdgriffith$elm_ui$Internal$Model$ChildrenBehind(
  						A2($elm$core$List$cons, nearby, existingBehind));
  				} else {
  					return A2(
  						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
  						existingBehind,
  						_List_fromArray(
  							[nearby]));
  				}
  			case 2:
  				var existingInFront = existing.a;
  				if (location === 5) {
  					return A2(
  						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
  						_List_fromArray(
  							[nearby]),
  						existingInFront);
  				} else {
  					return $mdgriffith$elm_ui$Internal$Model$ChildrenInFront(
  						A2($elm$core$List$cons, nearby, existingInFront));
  				}
  			default:
  				var existingBehind = existing.a;
  				var existingInFront = existing.b;
  				if (location === 5) {
  					return A2(
  						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
  						A2($elm$core$List$cons, nearby, existingBehind),
  						existingInFront);
  				} else {
  					return A2(
  						$mdgriffith$elm_ui$Internal$Model$ChildrenBehindAndInFront,
  						existingBehind,
  						A2($elm$core$List$cons, nearby, existingInFront));
  				}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$Embedded = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$NodeName = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$addNodeName = F2(
  	function (newNode, old) {
  		switch (old.$) {
  			case 0:
  				return $mdgriffith$elm_ui$Internal$Model$NodeName(newNode);
  			case 1:
  				var name = old.a;
  				return A2($mdgriffith$elm_ui$Internal$Model$Embedded, name, newNode);
  			default:
  				var x = old.a;
  				var y = old.b;
  				return A2($mdgriffith$elm_ui$Internal$Model$Embedded, x, y);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$alignXName = function (align) {
  	switch (align) {
  		case 0:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.bC);
  		case 2:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.bD);
  		default:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a6 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cI);
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$alignYName = function (align) {
  	switch (align) {
  		case 0:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a7 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cO);
  		case 2:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a7 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cH);
  		default:
  			return $mdgriffith$elm_ui$Internal$Style$classes.a7 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.cJ);
  	}
  };
  var $elm$virtual_dom$VirtualDom$attribute = F2(
  	function (key, value) {
  		return A2(
  			_VirtualDom_attribute,
  			_VirtualDom_noOnOrFormAction(key),
  			_VirtualDom_noJavaScriptOrHtmlUri(value));
  	});
  var $mdgriffith$elm_ui$Internal$Model$FullTransform = F4(
  	function (a, b, c, d) {
  		return {$: 2, a: a, b: b, c: c, d: d};
  	});
  var $mdgriffith$elm_ui$Internal$Model$Moved = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$composeTransformation = F2(
  	function (transform, component) {
  		switch (transform.$) {
  			case 0:
  				switch (component.$) {
  					case 0:
  						var x = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(x, 0, 0));
  					case 1:
  						var y = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(0, y, 0));
  					case 2:
  						var z = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(0, 0, z));
  					case 3:
  						var xyz = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(xyz);
  					case 4:
  						var xyz = component.a;
  						var angle = component.b;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							_Utils_Tuple3(0, 0, 0),
  							_Utils_Tuple3(1, 1, 1),
  							xyz,
  							angle);
  					default:
  						var xyz = component.a;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							_Utils_Tuple3(0, 0, 0),
  							xyz,
  							_Utils_Tuple3(0, 0, 1),
  							0);
  				}
  			case 1:
  				var moved = transform.a;
  				var x = moved.a;
  				var y = moved.b;
  				var z = moved.c;
  				switch (component.$) {
  					case 0:
  						var newX = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(newX, y, z));
  					case 1:
  						var newY = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(x, newY, z));
  					case 2:
  						var newZ = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(
  							_Utils_Tuple3(x, y, newZ));
  					case 3:
  						var xyz = component.a;
  						return $mdgriffith$elm_ui$Internal$Model$Moved(xyz);
  					case 4:
  						var xyz = component.a;
  						var angle = component.b;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							moved,
  							_Utils_Tuple3(1, 1, 1),
  							xyz,
  							angle);
  					default:
  						var scale = component.a;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							moved,
  							scale,
  							_Utils_Tuple3(0, 0, 1),
  							0);
  				}
  			default:
  				var moved = transform.a;
  				var x = moved.a;
  				var y = moved.b;
  				var z = moved.c;
  				var scaled = transform.b;
  				var origin = transform.c;
  				var angle = transform.d;
  				switch (component.$) {
  					case 0:
  						var newX = component.a;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							_Utils_Tuple3(newX, y, z),
  							scaled,
  							origin,
  							angle);
  					case 1:
  						var newY = component.a;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							_Utils_Tuple3(x, newY, z),
  							scaled,
  							origin,
  							angle);
  					case 2:
  						var newZ = component.a;
  						return A4(
  							$mdgriffith$elm_ui$Internal$Model$FullTransform,
  							_Utils_Tuple3(x, y, newZ),
  							scaled,
  							origin,
  							angle);
  					case 3:
  						var newMove = component.a;
  						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, newMove, scaled, origin, angle);
  					case 4:
  						var newOrigin = component.a;
  						var newAngle = component.b;
  						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, scaled, newOrigin, newAngle);
  					default:
  						var newScale = component.a;
  						return A4($mdgriffith$elm_ui$Internal$Model$FullTransform, moved, newScale, origin, angle);
  				}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Flag$height = $mdgriffith$elm_ui$Internal$Flag$flag(7);
  var $mdgriffith$elm_ui$Internal$Flag$heightContent = $mdgriffith$elm_ui$Internal$Flag$flag(36);
  var $mdgriffith$elm_ui$Internal$Flag$merge = F2(
  	function (_v0, _v1) {
  		var one = _v0.a;
  		var two = _v0.b;
  		var three = _v1.a;
  		var four = _v1.b;
  		return A2($mdgriffith$elm_ui$Internal$Flag$Field, one | three, two | four);
  	});
  var $mdgriffith$elm_ui$Internal$Flag$none = A2($mdgriffith$elm_ui$Internal$Flag$Field, 0, 0);
  var $mdgriffith$elm_ui$Internal$Model$renderHeight = function (h) {
  	switch (h.$) {
  		case 0:
  			var px = h.a;
  			var val = $elm$core$String$fromInt(px);
  			var name = 'height-px-' + val;
  			return _Utils_Tuple3(
  				$mdgriffith$elm_ui$Internal$Flag$none,
  				$mdgriffith$elm_ui$Internal$Style$classes.bT + (' ' + name),
  				_List_fromArray(
  					[
  						A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height', val + 'px')
  					]));
  		case 1:
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightContent, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.bh,
  				_List_Nil);
  		case 2:
  			var portion = h.a;
  			return (portion === 1) ? _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.bi,
  				_List_Nil) : _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightFill, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.bU + (' height-fill-' + $elm$core$String$fromInt(portion)),
  				_List_fromArray(
  					[
  						A3(
  						$mdgriffith$elm_ui$Internal$Model$Single,
  						$mdgriffith$elm_ui$Internal$Style$classes.cQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.I + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
  							'height-fill-' + $elm$core$String$fromInt(portion))))),
  						'flex-grow',
  						$elm$core$String$fromInt(portion * 100000))
  					]));
  		case 3:
  			var minSize = h.a;
  			var len = h.b;
  			var cls = 'min-height-' + $elm$core$String$fromInt(minSize);
  			var style = A3(
  				$mdgriffith$elm_ui$Internal$Model$Single,
  				cls,
  				'min-height',
  				$elm$core$String$fromInt(minSize) + 'px');
  			var _v1 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len);
  			var newFlag = _v1.a;
  			var newAttrs = _v1.b;
  			var newStyle = _v1.c;
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag),
  				cls + (' ' + newAttrs),
  				A2($elm$core$List$cons, style, newStyle));
  		default:
  			var maxSize = h.a;
  			var len = h.b;
  			var cls = 'max-height-' + $elm$core$String$fromInt(maxSize);
  			var style = A3(
  				$mdgriffith$elm_ui$Internal$Model$Single,
  				cls,
  				'max-height',
  				$elm$core$String$fromInt(maxSize) + 'px');
  			var _v2 = $mdgriffith$elm_ui$Internal$Model$renderHeight(len);
  			var newFlag = _v2.a;
  			var newAttrs = _v2.b;
  			var newStyle = _v2.c;
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$heightBetween, newFlag),
  				cls + (' ' + newAttrs),
  				A2($elm$core$List$cons, style, newStyle));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Flag$widthContent = $mdgriffith$elm_ui$Internal$Flag$flag(38);
  var $mdgriffith$elm_ui$Internal$Model$renderWidth = function (w) {
  	switch (w.$) {
  		case 0:
  			var px = w.a;
  			return _Utils_Tuple3(
  				$mdgriffith$elm_ui$Internal$Flag$none,
  				$mdgriffith$elm_ui$Internal$Style$classes.cz + (' width-px-' + $elm$core$String$fromInt(px)),
  				_List_fromArray(
  					[
  						A3(
  						$mdgriffith$elm_ui$Internal$Model$Single,
  						'width-px-' + $elm$core$String$fromInt(px),
  						'width',
  						$elm$core$String$fromInt(px) + 'px')
  					]));
  		case 1:
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthContent, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.by,
  				_List_Nil);
  		case 2:
  			var portion = w.a;
  			return (portion === 1) ? _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.bz,
  				_List_Nil) : _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthFill, $mdgriffith$elm_ui$Internal$Flag$none),
  				$mdgriffith$elm_ui$Internal$Style$classes.cA + (' width-fill-' + $elm$core$String$fromInt(portion)),
  				_List_fromArray(
  					[
  						A3(
  						$mdgriffith$elm_ui$Internal$Model$Single,
  						$mdgriffith$elm_ui$Internal$Style$classes.cQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.aX + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
  							'width-fill-' + $elm$core$String$fromInt(portion))))),
  						'flex-grow',
  						$elm$core$String$fromInt(portion * 100000))
  					]));
  		case 3:
  			var minSize = w.a;
  			var len = w.b;
  			var cls = 'min-width-' + $elm$core$String$fromInt(minSize);
  			var style = A3(
  				$mdgriffith$elm_ui$Internal$Model$Single,
  				cls,
  				'min-width',
  				$elm$core$String$fromInt(minSize) + 'px');
  			var _v1 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len);
  			var newFlag = _v1.a;
  			var newAttrs = _v1.b;
  			var newStyle = _v1.c;
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag),
  				cls + (' ' + newAttrs),
  				A2($elm$core$List$cons, style, newStyle));
  		default:
  			var maxSize = w.a;
  			var len = w.b;
  			var cls = 'max-width-' + $elm$core$String$fromInt(maxSize);
  			var style = A3(
  				$mdgriffith$elm_ui$Internal$Model$Single,
  				cls,
  				'max-width',
  				$elm$core$String$fromInt(maxSize) + 'px');
  			var _v2 = $mdgriffith$elm_ui$Internal$Model$renderWidth(len);
  			var newFlag = _v2.a;
  			var newAttrs = _v2.b;
  			var newStyle = _v2.c;
  			return _Utils_Tuple3(
  				A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$widthBetween, newFlag),
  				cls + (' ' + newAttrs),
  				A2($elm$core$List$cons, style, newStyle));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Flag$borderWidth = $mdgriffith$elm_ui$Internal$Flag$flag(27);
  var $mdgriffith$elm_ui$Internal$Model$skippable = F2(
  	function (flag, style) {
  		if (_Utils_eq(flag, $mdgriffith$elm_ui$Internal$Flag$borderWidth)) {
  			if (style.$ === 3) {
  				var val = style.c;
  				switch (val) {
  					case '0px':
  						return true;
  					case '1px':
  						return true;
  					case '2px':
  						return true;
  					case '3px':
  						return true;
  					case '4px':
  						return true;
  					case '5px':
  						return true;
  					case '6px':
  						return true;
  					default:
  						return false;
  				}
  			} else {
  				return false;
  			}
  		} else {
  			switch (style.$) {
  				case 2:
  					var i = style.a;
  					return (i >= 8) && (i <= 32);
  				case 7:
  					var name = style.a;
  					var t = style.b;
  					var r = style.c;
  					var b = style.d;
  					var l = style.e;
  					return _Utils_eq(t, b) && (_Utils_eq(t, r) && (_Utils_eq(t, l) && ((t >= 0) && (t <= 24))));
  				default:
  					return false;
  			}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Flag$width = $mdgriffith$elm_ui$Internal$Flag$flag(6);
  var $mdgriffith$elm_ui$Internal$Flag$xAlign = $mdgriffith$elm_ui$Internal$Flag$flag(30);
  var $mdgriffith$elm_ui$Internal$Flag$yAlign = $mdgriffith$elm_ui$Internal$Flag$flag(29);
  var $mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive = F8(
  	function (classes, node, has, transform, styles, attrs, children, elementAttrs) {
  		gatherAttrRecursive:
  		while (true) {
  			if (!elementAttrs.b) {
  				var _v1 = $mdgriffith$elm_ui$Internal$Model$transformClass(transform);
  				if (_v1.$ === 1) {
  					return {
  						R: A2(
  							$elm$core$List$cons,
  							$elm$html$Html$Attributes$class(classes),
  							attrs),
  						S: children,
  						U: has,
  						Y: node,
  						d7: styles
  					};
  				} else {
  					var _class = _v1.a;
  					return {
  						R: A2(
  							$elm$core$List$cons,
  							$elm$html$Html$Attributes$class(classes + (' ' + _class)),
  							attrs),
  						S: children,
  						U: has,
  						Y: node,
  						d7: A2(
  							$elm$core$List$cons,
  							$mdgriffith$elm_ui$Internal$Model$Transform(transform),
  							styles)
  					};
  				}
  			} else {
  				var attribute = elementAttrs.a;
  				var remaining = elementAttrs.b;
  				switch (attribute.$) {
  					case 0:
  						var $temp$classes = classes,
  							$temp$node = node,
  							$temp$has = has,
  							$temp$transform = transform,
  							$temp$styles = styles,
  							$temp$attrs = attrs,
  							$temp$children = children,
  							$temp$elementAttrs = remaining;
  						classes = $temp$classes;
  						node = $temp$node;
  						has = $temp$has;
  						transform = $temp$transform;
  						styles = $temp$styles;
  						attrs = $temp$attrs;
  						children = $temp$children;
  						elementAttrs = $temp$elementAttrs;
  						continue gatherAttrRecursive;
  					case 3:
  						var flag = attribute.a;
  						var exactClassName = attribute.b;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							var $temp$classes = exactClassName + (' ' + classes),
  								$temp$node = node,
  								$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						}
  					case 1:
  						var actualAttribute = attribute.a;
  						var $temp$classes = classes,
  							$temp$node = node,
  							$temp$has = has,
  							$temp$transform = transform,
  							$temp$styles = styles,
  							$temp$attrs = A2($elm$core$List$cons, actualAttribute, attrs),
  							$temp$children = children,
  							$temp$elementAttrs = remaining;
  						classes = $temp$classes;
  						node = $temp$node;
  						has = $temp$has;
  						transform = $temp$transform;
  						styles = $temp$styles;
  						attrs = $temp$attrs;
  						children = $temp$children;
  						elementAttrs = $temp$elementAttrs;
  						continue gatherAttrRecursive;
  					case 4:
  						var flag = attribute.a;
  						var style = attribute.b;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, flag, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							if (A2($mdgriffith$elm_ui$Internal$Model$skippable, flag, style)) {
  								var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes),
  									$temp$node = node,
  									$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							} else {
  								var $temp$classes = $mdgriffith$elm_ui$Internal$Model$getStyleName(style) + (' ' + classes),
  									$temp$node = node,
  									$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
  									$temp$transform = transform,
  									$temp$styles = A2($elm$core$List$cons, style, styles),
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							}
  						}
  					case 10:
  						var flag = attribute.a;
  						var component = attribute.b;
  						var $temp$classes = classes,
  							$temp$node = node,
  							$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, flag, has),
  							$temp$transform = A2($mdgriffith$elm_ui$Internal$Model$composeTransformation, transform, component),
  							$temp$styles = styles,
  							$temp$attrs = attrs,
  							$temp$children = children,
  							$temp$elementAttrs = remaining;
  						classes = $temp$classes;
  						node = $temp$node;
  						has = $temp$has;
  						transform = $temp$transform;
  						styles = $temp$styles;
  						attrs = $temp$attrs;
  						children = $temp$children;
  						elementAttrs = $temp$elementAttrs;
  						continue gatherAttrRecursive;
  					case 7:
  						var width = attribute.a;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$width, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							switch (width.$) {
  								case 0:
  									var px = width.a;
  									var $temp$classes = ($mdgriffith$elm_ui$Internal$Style$classes.cz + (' width-px-' + $elm$core$String$fromInt(px))) + (' ' + classes),
  										$temp$node = node,
  										$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has),
  										$temp$transform = transform,
  										$temp$styles = A2(
  										$elm$core$List$cons,
  										A3(
  											$mdgriffith$elm_ui$Internal$Model$Single,
  											'width-px-' + $elm$core$String$fromInt(px),
  											'width',
  											$elm$core$String$fromInt(px) + 'px'),
  										styles),
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  								case 1:
  									var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.by),
  										$temp$node = node,
  										$temp$has = A2(
  										$mdgriffith$elm_ui$Internal$Flag$add,
  										$mdgriffith$elm_ui$Internal$Flag$widthContent,
  										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
  										$temp$transform = transform,
  										$temp$styles = styles,
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  								case 2:
  									var portion = width.a;
  									if (portion === 1) {
  										var $temp$classes = classes + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.bz),
  											$temp$node = node,
  											$temp$has = A2(
  											$mdgriffith$elm_ui$Internal$Flag$add,
  											$mdgriffith$elm_ui$Internal$Flag$widthFill,
  											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
  											$temp$transform = transform,
  											$temp$styles = styles,
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									} else {
  										var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.cA + (' width-fill-' + $elm$core$String$fromInt(portion)))),
  											$temp$node = node,
  											$temp$has = A2(
  											$mdgriffith$elm_ui$Internal$Flag$add,
  											$mdgriffith$elm_ui$Internal$Flag$widthFill,
  											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
  											$temp$transform = transform,
  											$temp$styles = A2(
  											$elm$core$List$cons,
  											A3(
  												$mdgriffith$elm_ui$Internal$Model$Single,
  												$mdgriffith$elm_ui$Internal$Style$classes.cQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.aX + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
  													'width-fill-' + $elm$core$String$fromInt(portion))))),
  												'flex-grow',
  												$elm$core$String$fromInt(portion * 100000)),
  											styles),
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									}
  								default:
  									var _v4 = $mdgriffith$elm_ui$Internal$Model$renderWidth(width);
  									var addToFlags = _v4.a;
  									var newClass = _v4.b;
  									var newStyles = _v4.c;
  									var $temp$classes = classes + (' ' + newClass),
  										$temp$node = node,
  										$temp$has = A2(
  										$mdgriffith$elm_ui$Internal$Flag$merge,
  										addToFlags,
  										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$width, has)),
  										$temp$transform = transform,
  										$temp$styles = _Utils_ap(newStyles, styles),
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  							}
  						}
  					case 8:
  						var height = attribute.a;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$height, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							switch (height.$) {
  								case 0:
  									var px = height.a;
  									var val = $elm$core$String$fromInt(px) + 'px';
  									var name = 'height-px-' + val;
  									var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.bT + (' ' + (name + (' ' + classes))),
  										$temp$node = node,
  										$temp$has = A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has),
  										$temp$transform = transform,
  										$temp$styles = A2(
  										$elm$core$List$cons,
  										A3($mdgriffith$elm_ui$Internal$Model$Single, name, 'height ', val),
  										styles),
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  								case 1:
  									var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.bh + (' ' + classes),
  										$temp$node = node,
  										$temp$has = A2(
  										$mdgriffith$elm_ui$Internal$Flag$add,
  										$mdgriffith$elm_ui$Internal$Flag$heightContent,
  										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
  										$temp$transform = transform,
  										$temp$styles = styles,
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  								case 2:
  									var portion = height.a;
  									if (portion === 1) {
  										var $temp$classes = $mdgriffith$elm_ui$Internal$Style$classes.bi + (' ' + classes),
  											$temp$node = node,
  											$temp$has = A2(
  											$mdgriffith$elm_ui$Internal$Flag$add,
  											$mdgriffith$elm_ui$Internal$Flag$heightFill,
  											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
  											$temp$transform = transform,
  											$temp$styles = styles,
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									} else {
  										var $temp$classes = classes + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.bU + (' height-fill-' + $elm$core$String$fromInt(portion)))),
  											$temp$node = node,
  											$temp$has = A2(
  											$mdgriffith$elm_ui$Internal$Flag$add,
  											$mdgriffith$elm_ui$Internal$Flag$heightFill,
  											A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
  											$temp$transform = transform,
  											$temp$styles = A2(
  											$elm$core$List$cons,
  											A3(
  												$mdgriffith$elm_ui$Internal$Model$Single,
  												$mdgriffith$elm_ui$Internal$Style$classes.cQ + ('.' + ($mdgriffith$elm_ui$Internal$Style$classes.I + (' > ' + $mdgriffith$elm_ui$Internal$Style$dot(
  													'height-fill-' + $elm$core$String$fromInt(portion))))),
  												'flex-grow',
  												$elm$core$String$fromInt(portion * 100000)),
  											styles),
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									}
  								default:
  									var _v6 = $mdgriffith$elm_ui$Internal$Model$renderHeight(height);
  									var addToFlags = _v6.a;
  									var newClass = _v6.b;
  									var newStyles = _v6.c;
  									var $temp$classes = classes + (' ' + newClass),
  										$temp$node = node,
  										$temp$has = A2(
  										$mdgriffith$elm_ui$Internal$Flag$merge,
  										addToFlags,
  										A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$height, has)),
  										$temp$transform = transform,
  										$temp$styles = _Utils_ap(newStyles, styles),
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  							}
  						}
  					case 2:
  						var description = attribute.a;
  						switch (description.$) {
  							case 0:
  								var $temp$classes = classes,
  									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'main', node),
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 1:
  								var $temp$classes = classes,
  									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'nav', node),
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 2:
  								var $temp$classes = classes,
  									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'footer', node),
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 3:
  								var $temp$classes = classes,
  									$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'aside', node),
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 4:
  								var i = description.a;
  								if (i <= 1) {
  									var $temp$classes = classes,
  										$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h1', node),
  										$temp$has = has,
  										$temp$transform = transform,
  										$temp$styles = styles,
  										$temp$attrs = attrs,
  										$temp$children = children,
  										$temp$elementAttrs = remaining;
  									classes = $temp$classes;
  									node = $temp$node;
  									has = $temp$has;
  									transform = $temp$transform;
  									styles = $temp$styles;
  									attrs = $temp$attrs;
  									children = $temp$children;
  									elementAttrs = $temp$elementAttrs;
  									continue gatherAttrRecursive;
  								} else {
  									if (i < 7) {
  										var $temp$classes = classes,
  											$temp$node = A2(
  											$mdgriffith$elm_ui$Internal$Model$addNodeName,
  											'h' + $elm$core$String$fromInt(i),
  											node),
  											$temp$has = has,
  											$temp$transform = transform,
  											$temp$styles = styles,
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									} else {
  										var $temp$classes = classes,
  											$temp$node = A2($mdgriffith$elm_ui$Internal$Model$addNodeName, 'h6', node),
  											$temp$has = has,
  											$temp$transform = transform,
  											$temp$styles = styles,
  											$temp$attrs = attrs,
  											$temp$children = children,
  											$temp$elementAttrs = remaining;
  										classes = $temp$classes;
  										node = $temp$node;
  										has = $temp$has;
  										transform = $temp$transform;
  										styles = $temp$styles;
  										attrs = $temp$attrs;
  										children = $temp$children;
  										elementAttrs = $temp$elementAttrs;
  										continue gatherAttrRecursive;
  									}
  								}
  							case 9:
  								var $temp$classes = classes,
  									$temp$node = node,
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = attrs,
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 8:
  								var $temp$classes = classes,
  									$temp$node = node,
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = A2(
  									$elm$core$List$cons,
  									A2($elm$virtual_dom$VirtualDom$attribute, 'role', 'button'),
  									attrs),
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 5:
  								var label = description.a;
  								var $temp$classes = classes,
  									$temp$node = node,
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = A2(
  									$elm$core$List$cons,
  									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-label', label),
  									attrs),
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							case 6:
  								var $temp$classes = classes,
  									$temp$node = node,
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = A2(
  									$elm$core$List$cons,
  									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'polite'),
  									attrs),
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  							default:
  								var $temp$classes = classes,
  									$temp$node = node,
  									$temp$has = has,
  									$temp$transform = transform,
  									$temp$styles = styles,
  									$temp$attrs = A2(
  									$elm$core$List$cons,
  									A2($elm$virtual_dom$VirtualDom$attribute, 'aria-live', 'assertive'),
  									attrs),
  									$temp$children = children,
  									$temp$elementAttrs = remaining;
  								classes = $temp$classes;
  								node = $temp$node;
  								has = $temp$has;
  								transform = $temp$transform;
  								styles = $temp$styles;
  								attrs = $temp$attrs;
  								children = $temp$children;
  								elementAttrs = $temp$elementAttrs;
  								continue gatherAttrRecursive;
  						}
  					case 9:
  						var location = attribute.a;
  						var elem = attribute.b;
  						var newStyles = function () {
  							switch (elem.$) {
  								case 3:
  									return styles;
  								case 2:
  									var str = elem.a;
  									return styles;
  								case 0:
  									var html = elem.a;
  									return styles;
  								default:
  									var styled = elem.a;
  									return _Utils_ap(styles, styled.d7);
  							}
  						}();
  						var $temp$classes = classes,
  							$temp$node = node,
  							$temp$has = has,
  							$temp$transform = transform,
  							$temp$styles = newStyles,
  							$temp$attrs = attrs,
  							$temp$children = A3($mdgriffith$elm_ui$Internal$Model$addNearbyElement, location, elem, children),
  							$temp$elementAttrs = remaining;
  						classes = $temp$classes;
  						node = $temp$node;
  						has = $temp$has;
  						transform = $temp$transform;
  						styles = $temp$styles;
  						attrs = $temp$attrs;
  						children = $temp$children;
  						elementAttrs = $temp$elementAttrs;
  						continue gatherAttrRecursive;
  					case 6:
  						var x = attribute.a;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignXName(x) + (' ' + classes),
  								$temp$node = node,
  								$temp$has = function (flags) {
  								switch (x) {
  									case 1:
  										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerX, flags);
  									case 2:
  										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignRight, flags);
  									default:
  										return flags;
  								}
  							}(
  								A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$xAlign, has)),
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						}
  					default:
  						var y = attribute.a;
  						if (A2($mdgriffith$elm_ui$Internal$Flag$present, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)) {
  							var $temp$classes = classes,
  								$temp$node = node,
  								$temp$has = has,
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						} else {
  							var $temp$classes = $mdgriffith$elm_ui$Internal$Model$alignYName(y) + (' ' + classes),
  								$temp$node = node,
  								$temp$has = function (flags) {
  								switch (y) {
  									case 1:
  										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$centerY, flags);
  									case 2:
  										return A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$alignBottom, flags);
  									default:
  										return flags;
  								}
  							}(
  								A2($mdgriffith$elm_ui$Internal$Flag$add, $mdgriffith$elm_ui$Internal$Flag$yAlign, has)),
  								$temp$transform = transform,
  								$temp$styles = styles,
  								$temp$attrs = attrs,
  								$temp$children = children,
  								$temp$elementAttrs = remaining;
  							classes = $temp$classes;
  							node = $temp$node;
  							has = $temp$has;
  							transform = $temp$transform;
  							styles = $temp$styles;
  							attrs = $temp$attrs;
  							children = $temp$children;
  							elementAttrs = $temp$elementAttrs;
  							continue gatherAttrRecursive;
  						}
  				}
  			}
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$Untransformed = {$: 0};
  var $mdgriffith$elm_ui$Internal$Model$untransformed = $mdgriffith$elm_ui$Internal$Model$Untransformed;
  var $mdgriffith$elm_ui$Internal$Model$element = F4(
  	function (context, node, attributes, children) {
  		return A3(
  			$mdgriffith$elm_ui$Internal$Model$createElement,
  			context,
  			children,
  			A8(
  				$mdgriffith$elm_ui$Internal$Model$gatherAttrRecursive,
  				$mdgriffith$elm_ui$Internal$Model$contextClasses(context),
  				node,
  				$mdgriffith$elm_ui$Internal$Flag$none,
  				$mdgriffith$elm_ui$Internal$Model$untransformed,
  				_List_Nil,
  				_List_Nil,
  				$mdgriffith$elm_ui$Internal$Model$NoNearbyChildren,
  				$elm$core$List$reverse(attributes)));
  	});
  var $mdgriffith$elm_ui$Internal$Model$Height = function (a) {
  	return {$: 8, a: a};
  };
  var $mdgriffith$elm_ui$Element$height = $mdgriffith$elm_ui$Internal$Model$Height;
  var $mdgriffith$elm_ui$Internal$Model$Attr = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$htmlClass = function (cls) {
  	return $mdgriffith$elm_ui$Internal$Model$Attr(
  		$elm$html$Html$Attributes$class(cls));
  };
  var $mdgriffith$elm_ui$Internal$Model$Content = {$: 1};
  var $mdgriffith$elm_ui$Element$shrink = $mdgriffith$elm_ui$Internal$Model$Content;
  var $mdgriffith$elm_ui$Internal$Model$Width = function (a) {
  	return {$: 7, a: a};
  };
  var $mdgriffith$elm_ui$Element$width = $mdgriffith$elm_ui$Internal$Model$Width;
  var $mdgriffith$elm_ui$Element$column = F2(
  	function (attrs, children) {
  		return A4(
  			$mdgriffith$elm_ui$Internal$Model$element,
  			$mdgriffith$elm_ui$Internal$Model$asColumn,
  			$mdgriffith$elm_ui$Internal$Model$div,
  			A2(
  				$elm$core$List$cons,
  				$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.c9 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.at)),
  				A2(
  					$elm$core$List$cons,
  					$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
  					A2(
  						$elm$core$List$cons,
  						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
  						attrs))),
  			$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
  	});
  var $mdgriffith$elm_ui$Internal$Model$FontFamily = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$StyleClass = F2(
  	function (a, b) {
  		return {$: 4, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$fontFamily = $mdgriffith$elm_ui$Internal$Flag$flag(5);
  var $elm$core$String$toLower = _String_toLower;
  var $elm$core$String$words = _String_words;
  var $mdgriffith$elm_ui$Internal$Model$renderFontClassName = F2(
  	function (font, current) {
  		return _Utils_ap(
  			current,
  			function () {
  				switch (font.$) {
  					case 0:
  						return 'serif';
  					case 1:
  						return 'sans-serif';
  					case 2:
  						return 'monospace';
  					case 3:
  						var name = font.a;
  						return A2(
  							$elm$core$String$join,
  							'-',
  							$elm$core$String$words(
  								$elm$core$String$toLower(name)));
  					case 4:
  						var name = font.a;
  						var url = font.b;
  						return A2(
  							$elm$core$String$join,
  							'-',
  							$elm$core$String$words(
  								$elm$core$String$toLower(name)));
  					default:
  						var name = font.a.dK;
  						return A2(
  							$elm$core$String$join,
  							'-',
  							$elm$core$String$words(
  								$elm$core$String$toLower(name)));
  				}
  			}());
  	});
  var $mdgriffith$elm_ui$Element$Font$family = function (families) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$fontFamily,
  		A2(
  			$mdgriffith$elm_ui$Internal$Model$FontFamily,
  			A3($elm$core$List$foldl, $mdgriffith$elm_ui$Internal$Model$renderFontClassName, 'ff-', families),
  			families));
  };
  var $mdgriffith$elm_ui$Internal$Model$Fill = function (a) {
  	return {$: 2, a: a};
  };
  var $mdgriffith$elm_ui$Element$fill = $mdgriffith$elm_ui$Internal$Model$Fill(1);
  var $mdgriffith$elm_ui$Internal$Model$OnlyDynamic = F2(
  	function (a, b) {
  		return {$: 2, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic = F2(
  	function (a, b) {
  		return {$: 1, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$AllowHover = 1;
  var $mdgriffith$elm_ui$Internal$Model$Layout = 0;
  var $mdgriffith$elm_ui$Internal$Model$Rgba = F4(
  	function (a, b, c, d) {
  		return {$: 0, a: a, b: b, c: c, d: d};
  	});
  var $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle = {
  	cS: $elm$core$Maybe$Nothing,
  	cY: $elm$core$Maybe$Nothing,
  	d_: $elm$core$Maybe$Just(
  		{
  			ad: 0,
  			af: A4($mdgriffith$elm_ui$Internal$Model$Rgba, 155 / 255, 203 / 255, 1, 1),
  			ay: _Utils_Tuple2(0, 0),
  			aZ: 3
  		})
  };
  var $mdgriffith$elm_ui$Internal$Model$optionsToRecord = function (options) {
  	var combine = F2(
  		function (opt, record) {
  			switch (opt.$) {
  				case 0:
  					var hoverable = opt.a;
  					var _v4 = record.dr;
  					if (_v4.$ === 1) {
  						return _Utils_update(
  							record,
  							{
  								dr: $elm$core$Maybe$Just(hoverable)
  							});
  					} else {
  						return record;
  					}
  				case 1:
  					var focusStyle = opt.a;
  					var _v5 = record.dm;
  					if (_v5.$ === 1) {
  						return _Utils_update(
  							record,
  							{
  								dm: $elm$core$Maybe$Just(focusStyle)
  							});
  					} else {
  						return record;
  					}
  				default:
  					var renderMode = opt.a;
  					var _v6 = record.dJ;
  					if (_v6.$ === 1) {
  						return _Utils_update(
  							record,
  							{
  								dJ: $elm$core$Maybe$Just(renderMode)
  							});
  					} else {
  						return record;
  					}
  			}
  		});
  	var andFinally = function (record) {
  		return {
  			dm: function () {
  				var _v0 = record.dm;
  				if (_v0.$ === 1) {
  					return $mdgriffith$elm_ui$Internal$Model$focusDefaultStyle;
  				} else {
  					var focusable = _v0.a;
  					return focusable;
  				}
  			}(),
  			dr: function () {
  				var _v1 = record.dr;
  				if (_v1.$ === 1) {
  					return 1;
  				} else {
  					var hoverable = _v1.a;
  					return hoverable;
  				}
  			}(),
  			dJ: function () {
  				var _v2 = record.dJ;
  				if (_v2.$ === 1) {
  					return 0;
  				} else {
  					var actualMode = _v2.a;
  					return actualMode;
  				}
  			}()
  		};
  	};
  	return andFinally(
  		A3(
  			$elm$core$List$foldr,
  			combine,
  			{dm: $elm$core$Maybe$Nothing, dr: $elm$core$Maybe$Nothing, dJ: $elm$core$Maybe$Nothing},
  			options));
  };
  var $mdgriffith$elm_ui$Internal$Model$toHtml = F2(
  	function (mode, el) {
  		switch (el.$) {
  			case 0:
  				var html = el.a;
  				return html($mdgriffith$elm_ui$Internal$Model$asEl);
  			case 1:
  				var styles = el.a.d7;
  				var html = el.a.ds;
  				return A2(
  					html,
  					mode(styles),
  					$mdgriffith$elm_ui$Internal$Model$asEl);
  			case 2:
  				var text = el.a;
  				return $mdgriffith$elm_ui$Internal$Model$textElement(text);
  			default:
  				return $mdgriffith$elm_ui$Internal$Model$textElement('');
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$renderRoot = F3(
  	function (optionList, attributes, child) {
  		var options = $mdgriffith$elm_ui$Internal$Model$optionsToRecord(optionList);
  		var embedStyle = function () {
  			var _v0 = options.dJ;
  			if (_v0 === 1) {
  				return $mdgriffith$elm_ui$Internal$Model$OnlyDynamic(options);
  			} else {
  				return $mdgriffith$elm_ui$Internal$Model$StaticRootAndDynamic(options);
  			}
  		}();
  		return A2(
  			$mdgriffith$elm_ui$Internal$Model$toHtml,
  			embedStyle,
  			A4(
  				$mdgriffith$elm_ui$Internal$Model$element,
  				$mdgriffith$elm_ui$Internal$Model$asEl,
  				$mdgriffith$elm_ui$Internal$Model$div,
  				attributes,
  				$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  					_List_fromArray(
  						[child]))));
  	});
  var $mdgriffith$elm_ui$Internal$Model$Colored = F3(
  	function (a, b, c) {
  		return {$: 4, a: a, b: b, c: c};
  	});
  var $mdgriffith$elm_ui$Internal$Model$FontSize = function (a) {
  	return {$: 2, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$SansSerif = {$: 1};
  var $mdgriffith$elm_ui$Internal$Model$Typeface = function (a) {
  	return {$: 3, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Flag$bgColor = $mdgriffith$elm_ui$Internal$Flag$flag(8);
  var $mdgriffith$elm_ui$Internal$Flag$fontColor = $mdgriffith$elm_ui$Internal$Flag$flag(14);
  var $mdgriffith$elm_ui$Internal$Flag$fontSize = $mdgriffith$elm_ui$Internal$Flag$flag(4);
  var $mdgriffith$elm_ui$Internal$Model$formatColorClass = function (_v0) {
  	var red = _v0.a;
  	var green = _v0.b;
  	var blue = _v0.c;
  	var alpha = _v0.d;
  	return $mdgriffith$elm_ui$Internal$Model$floatClass(red) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(green) + ('-' + ($mdgriffith$elm_ui$Internal$Model$floatClass(blue) + ('-' + $mdgriffith$elm_ui$Internal$Model$floatClass(alpha))))));
  };
  var $mdgriffith$elm_ui$Internal$Model$rootStyle = function () {
  	var families = _List_fromArray(
  		[
  			$mdgriffith$elm_ui$Internal$Model$Typeface('Open Sans'),
  			$mdgriffith$elm_ui$Internal$Model$Typeface('Helvetica'),
  			$mdgriffith$elm_ui$Internal$Model$Typeface('Verdana'),
  			$mdgriffith$elm_ui$Internal$Model$SansSerif
  		]);
  	return _List_fromArray(
  		[
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$bgColor,
  			A3(
  				$mdgriffith$elm_ui$Internal$Model$Colored,
  				'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(
  					A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0)),
  				'background-color',
  				A4($mdgriffith$elm_ui$Internal$Model$Rgba, 1, 1, 1, 0))),
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$fontColor,
  			A3(
  				$mdgriffith$elm_ui$Internal$Model$Colored,
  				'fc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(
  					A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1)),
  				'color',
  				A4($mdgriffith$elm_ui$Internal$Model$Rgba, 0, 0, 0, 1))),
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$fontSize,
  			$mdgriffith$elm_ui$Internal$Model$FontSize(20)),
  			A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$fontFamily,
  			A2(
  				$mdgriffith$elm_ui$Internal$Model$FontFamily,
  				A3($elm$core$List$foldl, $mdgriffith$elm_ui$Internal$Model$renderFontClassName, 'font-', families),
  				families))
  		]);
  }();
  var $mdgriffith$elm_ui$Element$layoutWith = F3(
  	function (_v0, attrs, child) {
  		var options = _v0.b8;
  		return A3(
  			$mdgriffith$elm_ui$Internal$Model$renderRoot,
  			options,
  			A2(
  				$elm$core$List$cons,
  				$mdgriffith$elm_ui$Internal$Model$htmlClass(
  					A2(
  						$elm$core$String$join,
  						' ',
  						_List_fromArray(
  							[$mdgriffith$elm_ui$Internal$Style$classes.dU, $mdgriffith$elm_ui$Internal$Style$classes.cQ, $mdgriffith$elm_ui$Internal$Style$classes.d$]))),
  				_Utils_ap($mdgriffith$elm_ui$Internal$Model$rootStyle, attrs)),
  			child);
  	});
  var $mdgriffith$elm_ui$Element$layout = $mdgriffith$elm_ui$Element$layoutWith(
  	{b8: _List_Nil});
  var $mdgriffith$elm_ui$Internal$Model$Monospace = {$: 2};
  var $mdgriffith$elm_ui$Element$Font$monospace = $mdgriffith$elm_ui$Internal$Model$Monospace;
  var $mdgriffith$elm_ui$Internal$Model$OnRight = 2;
  var $mdgriffith$elm_ui$Internal$Model$Nearby = F2(
  	function (a, b) {
  		return {$: 9, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$NoAttribute = {$: 0};
  var $mdgriffith$elm_ui$Element$createNearby = F2(
  	function (loc, element) {
  		if (element.$ === 3) {
  			return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
  		} else {
  			return A2($mdgriffith$elm_ui$Internal$Model$Nearby, loc, element);
  		}
  	});
  var $mdgriffith$elm_ui$Element$onRight = function (element) {
  	return A2($mdgriffith$elm_ui$Element$createNearby, 2, element);
  };
  var $mdgriffith$elm_ui$Internal$Model$PaddingStyle = F5(
  	function (a, b, c, d, e) {
  		return {$: 7, a: a, b: b, c: c, d: d, e: e};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$padding = $mdgriffith$elm_ui$Internal$Flag$flag(2);
  var $mdgriffith$elm_ui$Element$padding = function (x) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$padding,
  		A5(
  			$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
  			'p-' + $elm$core$String$fromInt(x),
  			x,
  			x,
  			x,
  			x));
  };
  var $mdgriffith$elm_ui$Internal$Model$AsRow = 0;
  var $mdgriffith$elm_ui$Internal$Model$asRow = 0;
  var $mdgriffith$elm_ui$Element$row = F2(
  	function (attrs, children) {
  		return A4(
  			$mdgriffith$elm_ui$Internal$Model$element,
  			$mdgriffith$elm_ui$Internal$Model$asRow,
  			$mdgriffith$elm_ui$Internal$Model$div,
  			A2(
  				$elm$core$List$cons,
  				$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.at + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.J)),
  				A2(
  					$elm$core$List$cons,
  					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
  					A2(
  						$elm$core$List$cons,
  						$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
  						attrs))),
  			$mdgriffith$elm_ui$Internal$Model$Unkeyed(children));
  	});
  var $mdgriffith$elm_ui$Internal$Model$SpacingStyle = F3(
  	function (a, b, c) {
  		return {$: 5, a: a, b: b, c: c};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$spacing = $mdgriffith$elm_ui$Internal$Flag$flag(3);
  var $mdgriffith$elm_ui$Internal$Model$spacingName = F2(
  	function (x, y) {
  		return 'spacing-' + ($elm$core$String$fromInt(x) + ('-' + $elm$core$String$fromInt(y)));
  	});
  var $mdgriffith$elm_ui$Element$spacing = function (x) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$spacing,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$SpacingStyle,
  			A2($mdgriffith$elm_ui$Internal$Model$spacingName, x, x),
  			x,
  			x));
  };
  var $mdgriffith$elm_ui$Element$Font$typeface = $mdgriffith$elm_ui$Internal$Model$Typeface;
  var $mdgriffith$elm_ui$Element$el = F2(
  	function (attrs, child) {
  		return A4(
  			$mdgriffith$elm_ui$Internal$Model$element,
  			$mdgriffith$elm_ui$Internal$Model$asEl,
  			$mdgriffith$elm_ui$Internal$Model$div,
  			A2(
  				$elm$core$List$cons,
  				$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
  				A2(
  					$elm$core$List$cons,
  					$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
  					attrs)),
  			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  				_List_fromArray(
  					[child])));
  	});
  var $mdgriffith$elm_ui$Internal$Model$unstyled = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Unstyled, $elm$core$Basics$always);
  var $mdgriffith$elm_ui$Element$html = $mdgriffith$elm_ui$Internal$Model$unstyled;
  var $mdgriffith$elm_ui$Internal$Flag$letterSpacing = $mdgriffith$elm_ui$Internal$Flag$flag(16);
  var $mdgriffith$elm_ui$Element$Font$letterSpacing = function (offset) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$letterSpacing,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$Single,
  			'ls-' + $mdgriffith$elm_ui$Internal$Model$floatClass(offset),
  			'letter-spacing',
  			$elm$core$String$fromFloat(offset) + 'px'));
  };
  var $mdgriffith$elm_ui$Internal$Model$Empty = {$: 3};
  var $mdgriffith$elm_ui$Element$none = $mdgriffith$elm_ui$Internal$Model$Empty;
  var $mdgriffith$elm_ui$Internal$Model$paddingName = F4(
  	function (top, right, bottom, left) {
  		return 'pad-' + ($elm$core$String$fromInt(top) + ('-' + ($elm$core$String$fromInt(right) + ('-' + ($elm$core$String$fromInt(bottom) + ('-' + $elm$core$String$fromInt(left)))))));
  	});
  var $mdgriffith$elm_ui$Element$paddingEach = function (_v0) {
  	var top = _v0.ep;
  	var right = _v0.dT;
  	var bottom = _v0.c0;
  	var left = _v0.dF;
  	return (_Utils_eq(top, right) && (_Utils_eq(top, bottom) && _Utils_eq(top, left))) ? A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$padding,
  		A5(
  			$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
  			'p-' + $elm$core$String$fromInt(top),
  			top,
  			top,
  			top,
  			top)) : A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$padding,
  		A5(
  			$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
  			A4($mdgriffith$elm_ui$Internal$Model$paddingName, top, right, bottom, left),
  			top,
  			right,
  			bottom,
  			left));
  };
  var $elm$html$Html$pre = _VirtualDom_node('pre');
  var $elm$virtual_dom$VirtualDom$style = _VirtualDom_style;
  var $elm$html$Html$Attributes$style = $elm$virtual_dom$VirtualDom$style;
  var $author$project$CpuEmulator$viewAssemblerErrorMessage = function (errorMessage) {
  	if (errorMessage.$ === 1) {
  		return $mdgriffith$elm_ui$Element$none;
  	} else {
  		var _v1 = errorMessage.a;
  		var location = _v1.a;
  		var msg = _v1.b;
  		return A2(
  			$mdgriffith$elm_ui$Element$el,
  			_List_fromArray(
  				[
  					$mdgriffith$elm_ui$Element$paddingEach(
  					{c0: 0, dF: 20, dT: 0, ep: 0}),
  					$mdgriffith$elm_ui$Element$Font$letterSpacing(-1)
  				]),
  			$mdgriffith$elm_ui$Element$html(
  				A2(
  					$elm$html$Html$pre,
  					_List_fromArray(
  						[
  							A2($elm$html$Html$Attributes$style, 'white-space', 'pre-wrap'),
  							A2($elm$html$Html$Attributes$style, 'width', '50vw'),
  							A2($elm$html$Html$Attributes$style, 'margin', '0'),
  							A2($elm$html$Html$Attributes$style, 'line-height', '1.2em')
  						]),
  					_List_fromArray(
  						[
  							$elm$html$Html$text(
  							'⚠️ I got stuck while assembling line ' + ($elm$core$String$fromInt(location) + (':\n' + msg)))
  						]))));
  	}
  };
  var $author$project$CpuEmulator$StopEditingProgram = {$: 10};
  var $mdgriffith$elm_ui$Internal$Model$Button = {$: 8};
  var $mdgriffith$elm_ui$Internal$Model$Describe = function (a) {
  	return {$: 2, a: a};
  };
  var $elm$json$Json$Encode$bool = _Json_wrap;
  var $elm$html$Html$Attributes$boolProperty = F2(
  	function (key, bool) {
  		return A2(
  			_VirtualDom_property,
  			key,
  			$elm$json$Json$Encode$bool(bool));
  	});
  var $elm$html$Html$Attributes$disabled = $elm$html$Html$Attributes$boolProperty('disabled');
  var $mdgriffith$elm_ui$Element$Input$hasFocusStyle = function (attr) {
  	if (((attr.$ === 4) && (attr.b.$ === 11)) && (!attr.b.a)) {
  		var _v1 = attr.b;
  		var _v2 = _v1.a;
  		return true;
  	} else {
  		return false;
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$focusDefault = function (attrs) {
  	return A2($elm$core$List$any, $mdgriffith$elm_ui$Element$Input$hasFocusStyle, attrs) ? $mdgriffith$elm_ui$Internal$Model$NoAttribute : $mdgriffith$elm_ui$Internal$Model$htmlClass('focusable');
  };
  var $elm$virtual_dom$VirtualDom$Normal = function (a) {
  	return {$: 0, a: a};
  };
  var $elm$virtual_dom$VirtualDom$on = _VirtualDom_on;
  var $elm$html$Html$Events$on = F2(
  	function (event, decoder) {
  		return A2(
  			$elm$virtual_dom$VirtualDom$on,
  			event,
  			$elm$virtual_dom$VirtualDom$Normal(decoder));
  	});
  var $elm$html$Html$Events$onClick = function (msg) {
  	return A2(
  		$elm$html$Html$Events$on,
  		'click',
  		$elm$json$Json$Decode$succeed(msg));
  };
  var $mdgriffith$elm_ui$Element$Events$onClick = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Events$onClick);
  var $mdgriffith$elm_ui$Element$Input$enter = 'Enter';
  var $elm$json$Json$Decode$andThen = _Json_andThen;
  var $elm$json$Json$Decode$fail = _Json_fail;
  var $elm$json$Json$Decode$field = _Json_decodeField;
  var $elm$virtual_dom$VirtualDom$MayPreventDefault = function (a) {
  	return {$: 2, a: a};
  };
  var $elm$html$Html$Events$preventDefaultOn = F2(
  	function (event, decoder) {
  		return A2(
  			$elm$virtual_dom$VirtualDom$on,
  			event,
  			$elm$virtual_dom$VirtualDom$MayPreventDefault(decoder));
  	});
  var $mdgriffith$elm_ui$Element$Input$onKey = F2(
  	function (desiredCode, msg) {
  		var decode = function (code) {
  			return _Utils_eq(code, desiredCode) ? $elm$json$Json$Decode$succeed(msg) : $elm$json$Json$Decode$fail('Not the enter key');
  		};
  		var isKey = A2(
  			$elm$json$Json$Decode$andThen,
  			decode,
  			A2($elm$json$Json$Decode$field, 'key', $elm$json$Json$Decode$string));
  		return $mdgriffith$elm_ui$Internal$Model$Attr(
  			A2(
  				$elm$html$Html$Events$preventDefaultOn,
  				'keyup',
  				A2(
  					$elm$json$Json$Decode$map,
  					function (fired) {
  						return _Utils_Tuple2(fired, true);
  					},
  					isKey)));
  	});
  var $mdgriffith$elm_ui$Element$Input$onEnter = function (msg) {
  	return A2($mdgriffith$elm_ui$Element$Input$onKey, $mdgriffith$elm_ui$Element$Input$enter, msg);
  };
  var $mdgriffith$elm_ui$Internal$Model$Class = F2(
  	function (a, b) {
  		return {$: 3, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$cursor = $mdgriffith$elm_ui$Internal$Flag$flag(21);
  var $mdgriffith$elm_ui$Element$pointer = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$cursor, $mdgriffith$elm_ui$Internal$Style$classes.db);
  var $elm$html$Html$Attributes$tabindex = function (n) {
  	return A2(
  		_VirtualDom_attribute,
  		'tabIndex',
  		$elm$core$String$fromInt(n));
  };
  var $mdgriffith$elm_ui$Element$Input$button = F2(
  	function (attrs, _v0) {
  		var onPress = _v0.az;
  		var label = _v0.W;
  		return A4(
  			$mdgriffith$elm_ui$Internal$Model$element,
  			$mdgriffith$elm_ui$Internal$Model$asEl,
  			$mdgriffith$elm_ui$Internal$Model$div,
  			A2(
  				$elm$core$List$cons,
  				$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$shrink),
  				A2(
  					$elm$core$List$cons,
  					$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink),
  					A2(
  						$elm$core$List$cons,
  						$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.aR + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.J + (' ' + ($mdgriffith$elm_ui$Internal$Style$classes.dZ + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.b5)))))),
  						A2(
  							$elm$core$List$cons,
  							$mdgriffith$elm_ui$Element$pointer,
  							A2(
  								$elm$core$List$cons,
  								$mdgriffith$elm_ui$Element$Input$focusDefault(attrs),
  								A2(
  									$elm$core$List$cons,
  									$mdgriffith$elm_ui$Internal$Model$Describe($mdgriffith$elm_ui$Internal$Model$Button),
  									A2(
  										$elm$core$List$cons,
  										$mdgriffith$elm_ui$Internal$Model$Attr(
  											$elm$html$Html$Attributes$tabindex(0)),
  										function () {
  											if (onPress.$ === 1) {
  												return A2(
  													$elm$core$List$cons,
  													$mdgriffith$elm_ui$Internal$Model$Attr(
  														$elm$html$Html$Attributes$disabled(true)),
  													attrs);
  											} else {
  												var msg = onPress.a;
  												return A2(
  													$elm$core$List$cons,
  													$mdgriffith$elm_ui$Element$Events$onClick(msg),
  													A2(
  														$elm$core$List$cons,
  														$mdgriffith$elm_ui$Element$Input$onEnter(msg),
  														attrs));
  											}
  										}()))))))),
  			$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  				_List_fromArray(
  					[label])));
  	});
  var $mdgriffith$elm_ui$Element$htmlAttribute = $mdgriffith$elm_ui$Internal$Model$Attr;
  var $mdgriffith$elm_ui$Element$Background$color = function (clr) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$bgColor,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$Colored,
  			'bg-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr),
  			'background-color',
  			clr));
  };
  var $mdgriffith$elm_ui$Element$rgb255 = F3(
  	function (red, green, blue) {
  		return A4($mdgriffith$elm_ui$Internal$Model$Rgba, red / 255, green / 255, blue / 255, 1);
  	});
  var $author$project$CpuEmulator$colors = {
  	bK: A3($mdgriffith$elm_ui$Element$rgb255, 200, 200, 200),
  	bl: A3($mdgriffith$elm_ui$Element$rgb255, 102, 255, 102),
  	b0: A3($mdgriffith$elm_ui$Element$rgb255, 220, 220, 220),
  	b1: A3($mdgriffith$elm_ui$Element$rgb255, 255, 165, 0)
  };
  var $mdgriffith$elm_ui$Internal$Model$Hover = 1;
  var $mdgriffith$elm_ui$Internal$Model$PseudoSelector = F2(
  	function (a, b) {
  		return {$: 11, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$hover = $mdgriffith$elm_ui$Internal$Flag$flag(33);
  var $mdgriffith$elm_ui$Internal$Model$AlignX = function (a) {
  	return {$: 6, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Model$TransformComponent = F2(
  	function (a, b) {
  		return {$: 10, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Model$Text = function (a) {
  	return {$: 2, a: a};
  };
  var $elm$virtual_dom$VirtualDom$map = _VirtualDom_map;
  var $mdgriffith$elm_ui$Internal$Model$map = F2(
  	function (fn, el) {
  		switch (el.$) {
  			case 1:
  				var styled = el.a;
  				return $mdgriffith$elm_ui$Internal$Model$Styled(
  					{
  						ds: F2(
  							function (add, context) {
  								return A2(
  									$elm$virtual_dom$VirtualDom$map,
  									fn,
  									A2(styled.ds, add, context));
  							}),
  						d7: styled.d7
  					});
  			case 0:
  				var html = el.a;
  				return $mdgriffith$elm_ui$Internal$Model$Unstyled(
  					A2(
  						$elm$core$Basics$composeL,
  						$elm$virtual_dom$VirtualDom$map(fn),
  						html));
  			case 2:
  				var str = el.a;
  				return $mdgriffith$elm_ui$Internal$Model$Text(str);
  			default:
  				return $mdgriffith$elm_ui$Internal$Model$Empty;
  		}
  	});
  var $elm$virtual_dom$VirtualDom$mapAttribute = _VirtualDom_mapAttribute;
  var $mdgriffith$elm_ui$Internal$Model$mapAttrFromStyle = F2(
  	function (fn, attr) {
  		switch (attr.$) {
  			case 0:
  				return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
  			case 2:
  				var description = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$Describe(description);
  			case 6:
  				var x = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$AlignX(x);
  			case 5:
  				var y = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$AlignY(y);
  			case 7:
  				var x = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$Width(x);
  			case 8:
  				var x = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$Height(x);
  			case 3:
  				var x = attr.a;
  				var y = attr.b;
  				return A2($mdgriffith$elm_ui$Internal$Model$Class, x, y);
  			case 4:
  				var flag = attr.a;
  				var style = attr.b;
  				return A2($mdgriffith$elm_ui$Internal$Model$StyleClass, flag, style);
  			case 9:
  				var location = attr.a;
  				var elem = attr.b;
  				return A2(
  					$mdgriffith$elm_ui$Internal$Model$Nearby,
  					location,
  					A2($mdgriffith$elm_ui$Internal$Model$map, fn, elem));
  			case 1:
  				var htmlAttr = attr.a;
  				return $mdgriffith$elm_ui$Internal$Model$Attr(
  					A2($elm$virtual_dom$VirtualDom$mapAttribute, fn, htmlAttr));
  			default:
  				var fl = attr.a;
  				var trans = attr.b;
  				return A2($mdgriffith$elm_ui$Internal$Model$TransformComponent, fl, trans);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$removeNever = function (style) {
  	return A2($mdgriffith$elm_ui$Internal$Model$mapAttrFromStyle, $elm$core$Basics$never, style);
  };
  var $mdgriffith$elm_ui$Internal$Model$unwrapDecsHelper = F2(
  	function (attr, _v0) {
  		var styles = _v0.a;
  		var trans = _v0.b;
  		var _v1 = $mdgriffith$elm_ui$Internal$Model$removeNever(attr);
  		switch (_v1.$) {
  			case 4:
  				var style = _v1.b;
  				return _Utils_Tuple2(
  					A2($elm$core$List$cons, style, styles),
  					trans);
  			case 10:
  				var flag = _v1.a;
  				var component = _v1.b;
  				return _Utils_Tuple2(
  					styles,
  					A2($mdgriffith$elm_ui$Internal$Model$composeTransformation, trans, component));
  			default:
  				return _Utils_Tuple2(styles, trans);
  		}
  	});
  var $mdgriffith$elm_ui$Internal$Model$unwrapDecorations = function (attrs) {
  	var _v0 = A3(
  		$elm$core$List$foldl,
  		$mdgriffith$elm_ui$Internal$Model$unwrapDecsHelper,
  		_Utils_Tuple2(_List_Nil, $mdgriffith$elm_ui$Internal$Model$Untransformed),
  		attrs);
  	var styles = _v0.a;
  	var transform = _v0.b;
  	return A2(
  		$elm$core$List$cons,
  		$mdgriffith$elm_ui$Internal$Model$Transform(transform),
  		styles);
  };
  var $mdgriffith$elm_ui$Element$mouseOver = function (decs) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$hover,
  		A2(
  			$mdgriffith$elm_ui$Internal$Model$PseudoSelector,
  			1,
  			$mdgriffith$elm_ui$Internal$Model$unwrapDecorations(decs)));
  };
  var $mdgriffith$elm_ui$Element$paddingXY = F2(
  	function (x, y) {
  		return _Utils_eq(x, y) ? A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$padding,
  			A5(
  				$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
  				'p-' + $elm$core$String$fromInt(x),
  				x,
  				x,
  				x,
  				x)) : A2(
  			$mdgriffith$elm_ui$Internal$Model$StyleClass,
  			$mdgriffith$elm_ui$Internal$Flag$padding,
  			A5(
  				$mdgriffith$elm_ui$Internal$Model$PaddingStyle,
  				'p-' + ($elm$core$String$fromInt(x) + ('-' + $elm$core$String$fromInt(y))),
  				y,
  				x,
  				y,
  				x));
  	});
  var $author$project$CpuEmulator$styles = {
  	ae: _List_fromArray(
  		[
  			$mdgriffith$elm_ui$Element$Background$color($author$project$CpuEmulator$colors.b0),
  			$mdgriffith$elm_ui$Element$mouseOver(
  			_List_fromArray(
  				[
  					$mdgriffith$elm_ui$Element$Background$color($author$project$CpuEmulator$colors.bK)
  				])),
  			A2($mdgriffith$elm_ui$Element$paddingXY, 15, 10)
  		])
  };
  var $mdgriffith$elm_ui$Element$text = function (content) {
  	return $mdgriffith$elm_ui$Internal$Model$Text(content);
  };
  var $author$project$CpuEmulator$viewCloseEditorButton = function (isEditingProgram) {
  	return isEditingProgram ? A2(
  		$mdgriffith$elm_ui$Element$Input$button,
  		_Utils_ap(
  			$author$project$CpuEmulator$styles.ae,
  			_List_fromArray(
  				[
  					$mdgriffith$elm_ui$Element$htmlAttribute(
  					A2($elm$html$Html$Attributes$style, 'position', 'fixed')),
  					$mdgriffith$elm_ui$Element$htmlAttribute(
  					A2($elm$html$Html$Attributes$style, 'bottom', '10px')),
  					$mdgriffith$elm_ui$Element$htmlAttribute(
  					A2($elm$html$Html$Attributes$style, 'left', '0px'))
  				])),
  		{
  			W: $mdgriffith$elm_ui$Element$text('Save and Close'),
  			az: $elm$core$Maybe$Just($author$project$CpuEmulator$StopEditingProgram)
  		}) : $mdgriffith$elm_ui$Element$none;
  };
  var $author$project$CpuEmulator$StartEditingProgram = {$: 8};
  var $elm$svg$Svg$Attributes$d = _VirtualDom_attribute('d');
  var $feathericons$elm_feather$FeatherIcons$Icon = $elm$core$Basics$identity;
  var $feathericons$elm_feather$FeatherIcons$defaultAttributes = function (name) {
  	return {
  		aM: $elm$core$Maybe$Just('feather feather-' + name),
  		aZ: 24,
  		aD: '',
  		a_: 2,
  		a4: '0 0 24 24'
  	};
  };
  var $feathericons$elm_feather$FeatherIcons$makeBuilder = F2(
  	function (name, src) {
  		return {
  			p: $feathericons$elm_feather$FeatherIcons$defaultAttributes(name),
  			a: src
  		};
  	});
  var $elm$svg$Svg$trustedNode = _VirtualDom_nodeNS('http://www.w3.org/2000/svg');
  var $elm$svg$Svg$path = $elm$svg$Svg$trustedNode('path');
  var $feathericons$elm_feather$FeatherIcons$edit = A2(
  	$feathericons$elm_feather$FeatherIcons$makeBuilder,
  	'edit',
  	_List_fromArray(
  		[
  			A2(
  			$elm$svg$Svg$path,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$d('M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7')
  				]),
  			_List_Nil),
  			A2(
  			$elm$svg$Svg$path,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$d('M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z')
  				]),
  			_List_Nil)
  		]));
  var $elm$svg$Svg$Attributes$class = _VirtualDom_attribute('class');
  var $elm$svg$Svg$Attributes$fill = _VirtualDom_attribute('fill');
  var $elm$svg$Svg$Attributes$height = _VirtualDom_attribute('height');
  var $elm$svg$Svg$map = $elm$virtual_dom$VirtualDom$map;
  var $elm$svg$Svg$Attributes$stroke = _VirtualDom_attribute('stroke');
  var $elm$svg$Svg$Attributes$strokeLinecap = _VirtualDom_attribute('stroke-linecap');
  var $elm$svg$Svg$Attributes$strokeLinejoin = _VirtualDom_attribute('stroke-linejoin');
  var $elm$svg$Svg$Attributes$strokeWidth = _VirtualDom_attribute('stroke-width');
  var $elm$svg$Svg$svg = $elm$svg$Svg$trustedNode('svg');
  var $elm$svg$Svg$Attributes$viewBox = _VirtualDom_attribute('viewBox');
  var $elm$svg$Svg$Attributes$width = _VirtualDom_attribute('width');
  var $feathericons$elm_feather$FeatherIcons$toHtml = F2(
  	function (attributes, _v0) {
  		var src = _v0.a;
  		var attrs = _v0.p;
  		var strSize = $elm$core$String$fromFloat(attrs.aZ);
  		var baseAttributes = _List_fromArray(
  			[
  				$elm$svg$Svg$Attributes$fill('none'),
  				$elm$svg$Svg$Attributes$height(
  				_Utils_ap(strSize, attrs.aD)),
  				$elm$svg$Svg$Attributes$width(
  				_Utils_ap(strSize, attrs.aD)),
  				$elm$svg$Svg$Attributes$stroke('currentColor'),
  				$elm$svg$Svg$Attributes$strokeLinecap('round'),
  				$elm$svg$Svg$Attributes$strokeLinejoin('round'),
  				$elm$svg$Svg$Attributes$strokeWidth(
  				$elm$core$String$fromFloat(attrs.a_)),
  				$elm$svg$Svg$Attributes$viewBox(attrs.a4)
  			]);
  		var combinedAttributes = _Utils_ap(
  			function () {
  				var _v1 = attrs.aM;
  				if (!_v1.$) {
  					var c = _v1.a;
  					return A2(
  						$elm$core$List$cons,
  						$elm$svg$Svg$Attributes$class(c),
  						baseAttributes);
  				} else {
  					return baseAttributes;
  				}
  			}(),
  			attributes);
  		return A2(
  			$elm$svg$Svg$svg,
  			combinedAttributes,
  			A2(
  				$elm$core$List$map,
  				$elm$svg$Svg$map($elm$core$Basics$never),
  				src));
  	});
  var $author$project$CpuEmulator$viewEditButton = function (computer) {
  	return A2(
  		$mdgriffith$elm_ui$Element$Input$button,
  		$author$project$CpuEmulator$styles.ae,
  		{
  			W: $mdgriffith$elm_ui$Element$html(
  				A2($feathericons$elm_feather$FeatherIcons$toHtml, _List_Nil, $feathericons$elm_feather$FeatherIcons$edit)),
  			az: $elm$core$Maybe$Just($author$project$CpuEmulator$StartEditingProgram)
  		});
  };
  var $author$project$CpuEmulator$EditRam = F2(
  	function (a, b) {
  		return {$: 12, a: a, b: b};
  	});
  var $author$project$CpuEmulator$StartEditingRam = function (a) {
  	return {$: 11, a: a};
  };
  var $author$project$CpuEmulator$StopEditingRam = function (a) {
  	return {$: 13, a: a};
  };
  var $elm$html$Html$Attributes$id = $elm$html$Html$Attributes$stringProperty('id');
  var $author$project$CpuEmulator$indexedTable = F2(
  	function (attributes, _v0) {
  		var data = _v0.bc;
  		var columns = _v0.bb;
  		return A2(
  			$mdgriffith$elm_ui$Element$column,
  			_Utils_ap(
  				attributes,
  				_List_fromArray(
  					[
  						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
  					])),
  			A2(
  				$elm$core$List$indexedMap,
  				F2(
  					function (index, cell) {
  						return A2(
  							$mdgriffith$elm_ui$Element$row,
  							_List_fromArray(
  								[
  									$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
  								]),
  							A2(
  								$elm$core$List$map,
  								function (column) {
  									return A2(
  										$mdgriffith$elm_ui$Element$el,
  										_List_fromArray(
  											[
  												$mdgriffith$elm_ui$Element$width(column.aJ)
  											]),
  										A2(column.aq, index, cell));
  								},
  								columns));
  					}),
  				data));
  	});
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$Scroll = function (a) {
  	return {$: 0, a: a};
  };
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$ScrollPos = F3(
  	function (scrollTop, contentHeight, containerHeight) {
  		return {bH: containerHeight, bI: contentHeight, cn: scrollTop};
  	});
  var $elm$json$Json$Decode$at = F2(
  	function (fields, decoder) {
  		return A3($elm$core$List$foldr, $elm$json$Json$Decode$field, decoder, fields);
  	});
  var $elm$json$Json$Decode$int = _Json_decodeInt;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$clientHeight = A2(
  	$elm$json$Json$Decode$at,
  	_List_fromArray(
  		['target', 'clientHeight']),
  	$elm$json$Json$Decode$int);
  var $elm$json$Json$Decode$float = _Json_decodeFloat;
  var $elm$json$Json$Decode$map3 = _Json_map3;
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$offsetHeight = A2(
  	$elm$json$Json$Decode$at,
  	_List_fromArray(
  		['target', 'offsetHeight']),
  	$elm$json$Json$Decode$int);
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$decodeScrollPos = A4(
  	$elm$json$Json$Decode$map3,
  	$FabienHenon$elm_infinite_scroll$InfiniteScroll$ScrollPos,
  	A2(
  		$elm$json$Json$Decode$at,
  		_List_fromArray(
  			['target', 'scrollTop']),
  		$elm$json$Json$Decode$float),
  	A2(
  		$elm$json$Json$Decode$at,
  		_List_fromArray(
  			['target', 'scrollHeight']),
  		$elm$json$Json$Decode$int),
  	A3($elm$json$Json$Decode$map2, $elm$core$Basics$max, $FabienHenon$elm_infinite_scroll$InfiniteScroll$offsetHeight, $FabienHenon$elm_infinite_scroll$InfiniteScroll$clientHeight));
  var $elm$html$Html$Attributes$map = $elm$virtual_dom$VirtualDom$mapAttribute;
  var $elm$virtual_dom$VirtualDom$MayStopPropagation = function (a) {
  	return {$: 1, a: a};
  };
  var $elm$html$Html$Events$stopPropagationOn = F2(
  	function (event, decoder) {
  		return A2(
  			$elm$virtual_dom$VirtualDom$on,
  			event,
  			$elm$virtual_dom$VirtualDom$MayStopPropagation(decoder));
  	});
  var $FabienHenon$elm_infinite_scroll$InfiniteScroll$infiniteScroll = function (mapper) {
  	return A2(
  		$elm$html$Html$Attributes$map,
  		mapper,
  		A2(
  			$elm$html$Html$Events$stopPropagationOn,
  			'scroll',
  			A2(
  				$elm$json$Json$Decode$map,
  				function (pos) {
  					return _Utils_Tuple2(
  						$FabienHenon$elm_infinite_scroll$InfiniteScroll$Scroll(pos),
  						true);
  				},
  				$FabienHenon$elm_infinite_scroll$InfiniteScroll$decodeScrollPos)));
  };
  var $mdgriffith$elm_ui$Element$Input$HiddenLabel = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Element$Input$labelHidden = $mdgriffith$elm_ui$Element$Input$HiddenLabel;
  var $elm$html$Html$Events$onBlur = function (msg) {
  	return A2(
  		$elm$html$Html$Events$on,
  		'blur',
  		$elm$json$Json$Decode$succeed(msg));
  };
  var $mdgriffith$elm_ui$Element$Events$onLoseFocus = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Events$onBlur);
  var $mdgriffith$elm_ui$Internal$Model$Px = function (a) {
  	return {$: 0, a: a};
  };
  var $mdgriffith$elm_ui$Element$px = $mdgriffith$elm_ui$Internal$Model$Px;
  var $mdgriffith$elm_ui$Element$Input$TextInputNode = function (a) {
  	return {$: 0, a: a};
  };
  var $mdgriffith$elm_ui$Element$Input$TextArea = {$: 1};
  var $mdgriffith$elm_ui$Internal$Model$LivePolite = {$: 6};
  var $mdgriffith$elm_ui$Element$Region$announce = $mdgriffith$elm_ui$Internal$Model$Describe($mdgriffith$elm_ui$Internal$Model$LivePolite);
  var $mdgriffith$elm_ui$Element$Input$applyLabel = F3(
  	function (attrs, label, input) {
  		if (label.$ === 1) {
  			var labelText = label.a;
  			return A4(
  				$mdgriffith$elm_ui$Internal$Model$element,
  				$mdgriffith$elm_ui$Internal$Model$asColumn,
  				$mdgriffith$elm_ui$Internal$Model$NodeName('label'),
  				attrs,
  				$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  					_List_fromArray(
  						[input])));
  		} else {
  			var position = label.a;
  			var labelAttrs = label.b;
  			var labelChild = label.c;
  			var labelElement = A4(
  				$mdgriffith$elm_ui$Internal$Model$element,
  				$mdgriffith$elm_ui$Internal$Model$asEl,
  				$mdgriffith$elm_ui$Internal$Model$div,
  				labelAttrs,
  				$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  					_List_fromArray(
  						[labelChild])));
  			switch (position) {
  				case 2:
  					return A4(
  						$mdgriffith$elm_ui$Internal$Model$element,
  						$mdgriffith$elm_ui$Internal$Model$asColumn,
  						$mdgriffith$elm_ui$Internal$Model$NodeName('label'),
  						attrs,
  						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  							_List_fromArray(
  								[labelElement, input])));
  				case 3:
  					return A4(
  						$mdgriffith$elm_ui$Internal$Model$element,
  						$mdgriffith$elm_ui$Internal$Model$asColumn,
  						$mdgriffith$elm_ui$Internal$Model$NodeName('label'),
  						attrs,
  						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  							_List_fromArray(
  								[input, labelElement])));
  				case 0:
  					return A4(
  						$mdgriffith$elm_ui$Internal$Model$element,
  						$mdgriffith$elm_ui$Internal$Model$asRow,
  						$mdgriffith$elm_ui$Internal$Model$NodeName('label'),
  						attrs,
  						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  							_List_fromArray(
  								[input, labelElement])));
  				default:
  					return A4(
  						$mdgriffith$elm_ui$Internal$Model$element,
  						$mdgriffith$elm_ui$Internal$Model$asRow,
  						$mdgriffith$elm_ui$Internal$Model$NodeName('label'),
  						attrs,
  						$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  							_List_fromArray(
  								[labelElement, input])));
  			}
  		}
  	});
  var $elm$html$Html$Attributes$attribute = $elm$virtual_dom$VirtualDom$attribute;
  var $mdgriffith$elm_ui$Element$Input$autofill = A2(
  	$elm$core$Basics$composeL,
  	$mdgriffith$elm_ui$Internal$Model$Attr,
  	$elm$html$Html$Attributes$attribute('autocomplete'));
  var $mdgriffith$elm_ui$Internal$Model$Behind = 5;
  var $mdgriffith$elm_ui$Element$behindContent = function (element) {
  	return A2($mdgriffith$elm_ui$Element$createNearby, 5, element);
  };
  var $mdgriffith$elm_ui$Internal$Model$MoveY = function (a) {
  	return {$: 1, a: a};
  };
  var $mdgriffith$elm_ui$Internal$Flag$moveY = $mdgriffith$elm_ui$Internal$Flag$flag(26);
  var $mdgriffith$elm_ui$Element$moveUp = function (y) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$TransformComponent,
  		$mdgriffith$elm_ui$Internal$Flag$moveY,
  		$mdgriffith$elm_ui$Internal$Model$MoveY(-y));
  };
  var $mdgriffith$elm_ui$Element$Input$calcMoveToCompensateForPadding = function (attrs) {
  	var gatherSpacing = F2(
  		function (attr, found) {
  			if ((attr.$ === 4) && (attr.b.$ === 5)) {
  				var _v2 = attr.b;
  				var x = _v2.b;
  				var y = _v2.c;
  				if (found.$ === 1) {
  					return $elm$core$Maybe$Just(y);
  				} else {
  					return found;
  				}
  			} else {
  				return found;
  			}
  		});
  	var _v0 = A3($elm$core$List$foldr, gatherSpacing, $elm$core$Maybe$Nothing, attrs);
  	if (_v0.$ === 1) {
  		return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
  	} else {
  		var vSpace = _v0.a;
  		return $mdgriffith$elm_ui$Element$moveUp(
  			$elm$core$Basics$floor(vSpace / 2));
  	}
  };
  var $mdgriffith$elm_ui$Internal$Flag$overflow = $mdgriffith$elm_ui$Internal$Flag$flag(20);
  var $mdgriffith$elm_ui$Element$clip = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$overflow, $mdgriffith$elm_ui$Internal$Style$classes.c5);
  var $mdgriffith$elm_ui$Internal$Flag$borderColor = $mdgriffith$elm_ui$Internal$Flag$flag(28);
  var $mdgriffith$elm_ui$Element$Border$color = function (clr) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$borderColor,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$Colored,
  			'bc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(clr),
  			'border-color',
  			clr));
  };
  var $mdgriffith$elm_ui$Element$rgb = F3(
  	function (r, g, b) {
  		return A4($mdgriffith$elm_ui$Internal$Model$Rgba, r, g, b, 1);
  	});
  var $mdgriffith$elm_ui$Element$Input$darkGrey = A3($mdgriffith$elm_ui$Element$rgb, 186 / 255, 189 / 255, 182 / 255);
  var $mdgriffith$elm_ui$Element$Input$defaultTextPadding = A2($mdgriffith$elm_ui$Element$paddingXY, 12, 12);
  var $mdgriffith$elm_ui$Internal$Flag$borderRound = $mdgriffith$elm_ui$Internal$Flag$flag(17);
  var $mdgriffith$elm_ui$Element$Border$rounded = function (radius) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$borderRound,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$Single,
  			'br-' + $elm$core$String$fromInt(radius),
  			'border-radius',
  			$elm$core$String$fromInt(radius) + 'px'));
  };
  var $mdgriffith$elm_ui$Element$Input$white = A3($mdgriffith$elm_ui$Element$rgb, 1, 1, 1);
  var $mdgriffith$elm_ui$Internal$Model$BorderWidth = F5(
  	function (a, b, c, d, e) {
  		return {$: 6, a: a, b: b, c: c, d: d, e: e};
  	});
  var $mdgriffith$elm_ui$Element$Border$width = function (v) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$borderWidth,
  		A5(
  			$mdgriffith$elm_ui$Internal$Model$BorderWidth,
  			'b-' + $elm$core$String$fromInt(v),
  			v,
  			v,
  			v,
  			v));
  };
  var $mdgriffith$elm_ui$Element$Input$defaultTextBoxStyle = _List_fromArray(
  	[
  		$mdgriffith$elm_ui$Element$Input$defaultTextPadding,
  		$mdgriffith$elm_ui$Element$Border$rounded(3),
  		$mdgriffith$elm_ui$Element$Border$color($mdgriffith$elm_ui$Element$Input$darkGrey),
  		$mdgriffith$elm_ui$Element$Background$color($mdgriffith$elm_ui$Element$Input$white),
  		$mdgriffith$elm_ui$Element$Border$width(1),
  		$mdgriffith$elm_ui$Element$spacing(5),
  		$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  		$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$shrink)
  	]);
  var $mdgriffith$elm_ui$Element$Input$getHeight = function (attr) {
  	if (attr.$ === 8) {
  		var h = attr.a;
  		return $elm$core$Maybe$Just(h);
  	} else {
  		return $elm$core$Maybe$Nothing;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$Label = function (a) {
  	return {$: 5, a: a};
  };
  var $mdgriffith$elm_ui$Element$Input$hiddenLabelAttribute = function (label) {
  	if (label.$ === 1) {
  		var textLabel = label.a;
  		return $mdgriffith$elm_ui$Internal$Model$Describe(
  			$mdgriffith$elm_ui$Internal$Model$Label(textLabel));
  	} else {
  		return $mdgriffith$elm_ui$Internal$Model$NoAttribute;
  	}
  };
  var $mdgriffith$elm_ui$Internal$Model$InFront = 4;
  var $mdgriffith$elm_ui$Element$inFront = function (element) {
  	return A2($mdgriffith$elm_ui$Element$createNearby, 4, element);
  };
  var $mdgriffith$elm_ui$Element$Input$isConstrained = function (len) {
  	isConstrained:
  	while (true) {
  		switch (len.$) {
  			case 1:
  				return false;
  			case 0:
  				return true;
  			case 2:
  				return true;
  			case 3:
  				var l = len.b;
  				var $temp$len = l;
  				len = $temp$len;
  				continue isConstrained;
  			default:
  				var l = len.b;
  				return true;
  		}
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$isHiddenLabel = function (label) {
  	if (label.$ === 1) {
  		return true;
  	} else {
  		return false;
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$isStacked = function (label) {
  	if (!label.$) {
  		var loc = label.a;
  		switch (loc) {
  			case 0:
  				return false;
  			case 1:
  				return false;
  			case 2:
  				return true;
  			default:
  				return true;
  		}
  	} else {
  		return true;
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$negateBox = function (box) {
  	return {c0: -box.c0, dF: -box.dF, dT: -box.dT, ep: -box.ep};
  };
  var $elm$html$Html$Events$alwaysStop = function (x) {
  	return _Utils_Tuple2(x, true);
  };
  var $elm$html$Html$Events$targetValue = A2(
  	$elm$json$Json$Decode$at,
  	_List_fromArray(
  		['target', 'value']),
  	$elm$json$Json$Decode$string);
  var $elm$html$Html$Events$onInput = function (tagger) {
  	return A2(
  		$elm$html$Html$Events$stopPropagationOn,
  		'input',
  		A2(
  			$elm$json$Json$Decode$map,
  			$elm$html$Html$Events$alwaysStop,
  			A2($elm$json$Json$Decode$map, tagger, $elm$html$Html$Events$targetValue)));
  };
  var $mdgriffith$elm_ui$Element$Input$isFill = function (len) {
  	isFill:
  	while (true) {
  		switch (len.$) {
  			case 2:
  				return true;
  			case 1:
  				return false;
  			case 0:
  				return false;
  			case 3:
  				var l = len.b;
  				var $temp$len = l;
  				len = $temp$len;
  				continue isFill;
  			default:
  				var l = len.b;
  				var $temp$len = l;
  				len = $temp$len;
  				continue isFill;
  		}
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$isPixel = function (len) {
  	isPixel:
  	while (true) {
  		switch (len.$) {
  			case 1:
  				return false;
  			case 0:
  				return true;
  			case 2:
  				return false;
  			case 3:
  				var l = len.b;
  				var $temp$len = l;
  				len = $temp$len;
  				continue isPixel;
  			default:
  				var l = len.b;
  				var $temp$len = l;
  				len = $temp$len;
  				continue isPixel;
  		}
  	}
  };
  var $mdgriffith$elm_ui$Element$Input$redistributeOver = F4(
  	function (isMultiline, stacked, attr, els) {
  		switch (attr.$) {
  			case 9:
  				return _Utils_update(
  					els,
  					{
  						b: A2($elm$core$List$cons, attr, els.b)
  					});
  			case 7:
  				var width = attr.a;
  				return $mdgriffith$elm_ui$Element$Input$isFill(width) ? _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e),
  						j: A2($elm$core$List$cons, attr, els.j),
  						b: A2($elm$core$List$cons, attr, els.b)
  					}) : (stacked ? _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e)
  					}) : _Utils_update(
  					els,
  					{
  						b: A2($elm$core$List$cons, attr, els.b)
  					}));
  			case 8:
  				var height = attr.a;
  				return (!stacked) ? _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e),
  						b: A2($elm$core$List$cons, attr, els.b)
  					}) : ($mdgriffith$elm_ui$Element$Input$isFill(height) ? _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e),
  						b: A2($elm$core$List$cons, attr, els.b)
  					}) : ($mdgriffith$elm_ui$Element$Input$isPixel(height) ? _Utils_update(
  					els,
  					{
  						b: A2($elm$core$List$cons, attr, els.b)
  					}) : _Utils_update(
  					els,
  					{
  						b: A2($elm$core$List$cons, attr, els.b)
  					})));
  			case 6:
  				return _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e)
  					});
  			case 5:
  				return _Utils_update(
  					els,
  					{
  						e: A2($elm$core$List$cons, attr, els.e)
  					});
  			case 4:
  				switch (attr.b.$) {
  					case 5:
  						var _v1 = attr.b;
  						return _Utils_update(
  							els,
  							{
  								e: A2($elm$core$List$cons, attr, els.e),
  								j: A2($elm$core$List$cons, attr, els.j),
  								b: A2($elm$core$List$cons, attr, els.b),
  								ar: A2($elm$core$List$cons, attr, els.ar)
  							});
  					case 7:
  						var cls = attr.a;
  						var _v2 = attr.b;
  						var pad = _v2.a;
  						var t = _v2.b;
  						var r = _v2.c;
  						var b = _v2.d;
  						var l = _v2.e;
  						if (isMultiline) {
  							return _Utils_update(
  								els,
  								{
  									s: A2($elm$core$List$cons, attr, els.s),
  									b: A2($elm$core$List$cons, attr, els.b)
  								});
  						} else {
  							var reducedVerticalPadding = $mdgriffith$elm_ui$Element$paddingEach(
  								{
  									c0: b - A2($elm$core$Basics$min, t, b),
  									dF: l,
  									dT: r,
  									ep: t - A2($elm$core$Basics$min, t, b)
  								});
  							var newLineHeight = $mdgriffith$elm_ui$Element$htmlAttribute(
  								A2(
  									$elm$html$Html$Attributes$style,
  									'line-height',
  									'calc(1.0em + ' + ($elm$core$String$fromInt(
  										2 * A2($elm$core$Basics$min, t, b)) + 'px)')));
  							var newHeight = $mdgriffith$elm_ui$Element$htmlAttribute(
  								A2(
  									$elm$html$Html$Attributes$style,
  									'height',
  									'calc(1.0em + ' + ($elm$core$String$fromInt(
  										2 * A2($elm$core$Basics$min, t, b)) + 'px)')));
  							return _Utils_update(
  								els,
  								{
  									s: A2($elm$core$List$cons, attr, els.s),
  									j: A2(
  										$elm$core$List$cons,
  										newHeight,
  										A2($elm$core$List$cons, newLineHeight, els.j)),
  									b: A2($elm$core$List$cons, reducedVerticalPadding, els.b)
  								});
  						}
  					case 6:
  						var _v3 = attr.b;
  						return _Utils_update(
  							els,
  							{
  								s: A2($elm$core$List$cons, attr, els.s),
  								b: A2($elm$core$List$cons, attr, els.b)
  							});
  					case 10:
  						return _Utils_update(
  							els,
  							{
  								s: A2($elm$core$List$cons, attr, els.s),
  								b: A2($elm$core$List$cons, attr, els.b)
  							});
  					case 2:
  						return _Utils_update(
  							els,
  							{
  								e: A2($elm$core$List$cons, attr, els.e)
  							});
  					case 1:
  						var _v4 = attr.b;
  						return _Utils_update(
  							els,
  							{
  								e: A2($elm$core$List$cons, attr, els.e)
  							});
  					default:
  						var flag = attr.a;
  						var cls = attr.b;
  						return _Utils_update(
  							els,
  							{
  								b: A2($elm$core$List$cons, attr, els.b)
  							});
  				}
  			case 0:
  				return els;
  			case 1:
  				var a = attr.a;
  				return _Utils_update(
  					els,
  					{
  						j: A2($elm$core$List$cons, attr, els.j)
  					});
  			case 2:
  				return _Utils_update(
  					els,
  					{
  						j: A2($elm$core$List$cons, attr, els.j)
  					});
  			case 3:
  				return _Utils_update(
  					els,
  					{
  						b: A2($elm$core$List$cons, attr, els.b)
  					});
  			default:
  				return _Utils_update(
  					els,
  					{
  						j: A2($elm$core$List$cons, attr, els.j)
  					});
  		}
  	});
  var $mdgriffith$elm_ui$Element$Input$redistribute = F3(
  	function (isMultiline, stacked, attrs) {
  		return function (redist) {
  			return {
  				s: $elm$core$List$reverse(redist.s),
  				e: $elm$core$List$reverse(redist.e),
  				j: $elm$core$List$reverse(redist.j),
  				b: $elm$core$List$reverse(redist.b),
  				ar: $elm$core$List$reverse(redist.ar)
  			};
  		}(
  			A3(
  				$elm$core$List$foldl,
  				A2($mdgriffith$elm_ui$Element$Input$redistributeOver, isMultiline, stacked),
  				{s: _List_Nil, e: _List_Nil, j: _List_Nil, b: _List_Nil, ar: _List_Nil},
  				attrs));
  	});
  var $mdgriffith$elm_ui$Element$Input$renderBox = function (_v0) {
  	var top = _v0.ep;
  	var right = _v0.dT;
  	var bottom = _v0.c0;
  	var left = _v0.dF;
  	return $elm$core$String$fromInt(top) + ('px ' + ($elm$core$String$fromInt(right) + ('px ' + ($elm$core$String$fromInt(bottom) + ('px ' + ($elm$core$String$fromInt(left) + 'px'))))));
  };
  var $mdgriffith$elm_ui$Internal$Model$Transparency = F2(
  	function (a, b) {
  		return {$: 12, a: a, b: b};
  	});
  var $mdgriffith$elm_ui$Internal$Flag$transparency = $mdgriffith$elm_ui$Internal$Flag$flag(0);
  var $mdgriffith$elm_ui$Element$alpha = function (o) {
  	var transparency = function (x) {
  		return 1 - x;
  	}(
  		A2(
  			$elm$core$Basics$min,
  			1.0,
  			A2($elm$core$Basics$max, 0.0, o)));
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$transparency,
  		A2(
  			$mdgriffith$elm_ui$Internal$Model$Transparency,
  			'transparency-' + $mdgriffith$elm_ui$Internal$Model$floatClass(transparency),
  			transparency));
  };
  var $mdgriffith$elm_ui$Element$Input$charcoal = A3($mdgriffith$elm_ui$Element$rgb, 136 / 255, 138 / 255, 133 / 255);
  var $mdgriffith$elm_ui$Element$Font$color = function (fontColor) {
  	return A2(
  		$mdgriffith$elm_ui$Internal$Model$StyleClass,
  		$mdgriffith$elm_ui$Internal$Flag$fontColor,
  		A3(
  			$mdgriffith$elm_ui$Internal$Model$Colored,
  			'fc-' + $mdgriffith$elm_ui$Internal$Model$formatColorClass(fontColor),
  			'color',
  			fontColor));
  };
  var $mdgriffith$elm_ui$Element$rgba = $mdgriffith$elm_ui$Internal$Model$Rgba;
  var $mdgriffith$elm_ui$Element$Input$renderPlaceholder = F3(
  	function (_v0, forPlaceholder, on) {
  		var placeholderAttrs = _v0.a;
  		var placeholderEl = _v0.b;
  		return A2(
  			$mdgriffith$elm_ui$Element$el,
  			_Utils_ap(
  				forPlaceholder,
  				_Utils_ap(
  					_List_fromArray(
  						[
  							$mdgriffith$elm_ui$Element$Font$color($mdgriffith$elm_ui$Element$Input$charcoal),
  							$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.b5 + (' ' + $mdgriffith$elm_ui$Internal$Style$classes.dR)),
  							$mdgriffith$elm_ui$Element$clip,
  							$mdgriffith$elm_ui$Element$Border$color(
  							A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0)),
  							$mdgriffith$elm_ui$Element$Background$color(
  							A4($mdgriffith$elm_ui$Element$rgba, 0, 0, 0, 0)),
  							$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
  							$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  							$mdgriffith$elm_ui$Element$alpha(
  							on ? 1 : 0)
  						]),
  					placeholderAttrs)),
  			placeholderEl);
  	});
  var $mdgriffith$elm_ui$Element$scrollbarY = A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$overflow, $mdgriffith$elm_ui$Internal$Style$classes.dY);
  var $elm$html$Html$span = _VirtualDom_node('span');
  var $elm$html$Html$Attributes$spellcheck = $elm$html$Html$Attributes$boolProperty('spellcheck');
  var $mdgriffith$elm_ui$Element$Input$spellcheck = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Attributes$spellcheck);
  var $elm$html$Html$Attributes$type_ = $elm$html$Html$Attributes$stringProperty('type');
  var $elm$html$Html$Attributes$value = $elm$html$Html$Attributes$stringProperty('value');
  var $mdgriffith$elm_ui$Element$Input$value = A2($elm$core$Basics$composeL, $mdgriffith$elm_ui$Internal$Model$Attr, $elm$html$Html$Attributes$value);
  var $mdgriffith$elm_ui$Element$Input$textHelper = F3(
  	function (textInput, attrs, textOptions) {
  		var withDefaults = _Utils_ap($mdgriffith$elm_ui$Element$Input$defaultTextBoxStyle, attrs);
  		var redistributed = A3(
  			$mdgriffith$elm_ui$Element$Input$redistribute,
  			_Utils_eq(textInput.o, $mdgriffith$elm_ui$Element$Input$TextArea),
  			$mdgriffith$elm_ui$Element$Input$isStacked(textOptions.W),
  			withDefaults);
  		var onlySpacing = function (attr) {
  			if ((attr.$ === 4) && (attr.b.$ === 5)) {
  				var _v9 = attr.b;
  				return true;
  			} else {
  				return false;
  			}
  		};
  		var heightConstrained = function () {
  			var _v7 = textInput.o;
  			if (!_v7.$) {
  				var inputType = _v7.a;
  				return false;
  			} else {
  				return A2(
  					$elm$core$Maybe$withDefault,
  					false,
  					A2(
  						$elm$core$Maybe$map,
  						$mdgriffith$elm_ui$Element$Input$isConstrained,
  						$elm$core$List$head(
  							$elm$core$List$reverse(
  								A2($elm$core$List$filterMap, $mdgriffith$elm_ui$Element$Input$getHeight, withDefaults)))));
  			}
  		}();
  		var getPadding = function (attr) {
  			if ((attr.$ === 4) && (attr.b.$ === 7)) {
  				var cls = attr.a;
  				var _v6 = attr.b;
  				var pad = _v6.a;
  				var t = _v6.b;
  				var r = _v6.c;
  				var b = _v6.d;
  				var l = _v6.e;
  				return $elm$core$Maybe$Just(
  					{
  						c0: A2(
  							$elm$core$Basics$max,
  							0,
  							$elm$core$Basics$floor(b - 3)),
  						dF: A2(
  							$elm$core$Basics$max,
  							0,
  							$elm$core$Basics$floor(l - 3)),
  						dT: A2(
  							$elm$core$Basics$max,
  							0,
  							$elm$core$Basics$floor(r - 3)),
  						ep: A2(
  							$elm$core$Basics$max,
  							0,
  							$elm$core$Basics$floor(t - 3))
  					});
  			} else {
  				return $elm$core$Maybe$Nothing;
  			}
  		};
  		var parentPadding = A2(
  			$elm$core$Maybe$withDefault,
  			{c0: 0, dF: 0, dT: 0, ep: 0},
  			$elm$core$List$head(
  				$elm$core$List$reverse(
  					A2($elm$core$List$filterMap, getPadding, withDefaults))));
  		var inputElement = A4(
  			$mdgriffith$elm_ui$Internal$Model$element,
  			$mdgriffith$elm_ui$Internal$Model$asEl,
  			function () {
  				var _v3 = textInput.o;
  				if (!_v3.$) {
  					var inputType = _v3.a;
  					return $mdgriffith$elm_ui$Internal$Model$NodeName('input');
  				} else {
  					return $mdgriffith$elm_ui$Internal$Model$NodeName('textarea');
  				}
  			}(),
  			_Utils_ap(
  				function () {
  					var _v4 = textInput.o;
  					if (!_v4.$) {
  						var inputType = _v4.a;
  						return _List_fromArray(
  							[
  								$mdgriffith$elm_ui$Internal$Model$Attr(
  								$elm$html$Html$Attributes$type_(inputType)),
  								$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.dB)
  							]);
  					} else {
  						return _List_fromArray(
  							[
  								$mdgriffith$elm_ui$Element$clip,
  								$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
  								$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.dx),
  								$mdgriffith$elm_ui$Element$Input$calcMoveToCompensateForPadding(withDefaults),
  								$mdgriffith$elm_ui$Element$paddingEach(parentPadding),
  								$mdgriffith$elm_ui$Internal$Model$Attr(
  								A2(
  									$elm$html$Html$Attributes$style,
  									'margin',
  									$mdgriffith$elm_ui$Element$Input$renderBox(
  										$mdgriffith$elm_ui$Element$Input$negateBox(parentPadding)))),
  								$mdgriffith$elm_ui$Internal$Model$Attr(
  								A2($elm$html$Html$Attributes$style, 'box-sizing', 'content-box'))
  							]);
  					}
  				}(),
  				_Utils_ap(
  					_List_fromArray(
  						[
  							$mdgriffith$elm_ui$Element$Input$value(textOptions.ct),
  							$mdgriffith$elm_ui$Internal$Model$Attr(
  							$elm$html$Html$Events$onInput(textOptions.b7)),
  							$mdgriffith$elm_ui$Element$Input$hiddenLabelAttribute(textOptions.W),
  							$mdgriffith$elm_ui$Element$Input$spellcheck(textInput.A),
  							A2(
  							$elm$core$Maybe$withDefault,
  							$mdgriffith$elm_ui$Internal$Model$NoAttribute,
  							A2($elm$core$Maybe$map, $mdgriffith$elm_ui$Element$Input$autofill, textInput.x))
  						]),
  					redistributed.j)),
  			$mdgriffith$elm_ui$Internal$Model$Unkeyed(_List_Nil));
  		var wrappedInput = function () {
  			var _v0 = textInput.o;
  			if (_v0.$ === 1) {
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$element,
  					$mdgriffith$elm_ui$Internal$Model$asEl,
  					$mdgriffith$elm_ui$Internal$Model$div,
  					_Utils_ap(
  						(heightConstrained ? $elm$core$List$cons($mdgriffith$elm_ui$Element$scrollbarY) : $elm$core$Basics$identity)(
  							_List_fromArray(
  								[
  									$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  									A2($elm$core$List$any, $mdgriffith$elm_ui$Element$Input$hasFocusStyle, withDefaults) ? $mdgriffith$elm_ui$Internal$Model$NoAttribute : $mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.bP),
  									$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.dA)
  								])),
  						redistributed.b),
  					$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  						_List_fromArray(
  							[
  								A4(
  								$mdgriffith$elm_ui$Internal$Model$element,
  								$mdgriffith$elm_ui$Internal$Model$asParagraph,
  								$mdgriffith$elm_ui$Internal$Model$div,
  								A2(
  									$elm$core$List$cons,
  									$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  									A2(
  										$elm$core$List$cons,
  										$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
  										A2(
  											$elm$core$List$cons,
  											$mdgriffith$elm_ui$Element$inFront(inputElement),
  											A2(
  												$elm$core$List$cons,
  												$mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.dz),
  												redistributed.ar)))),
  								$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  									function () {
  										if (textOptions.ct === '') {
  											var _v1 = textOptions.ce;
  											if (_v1.$ === 1) {
  												return _List_fromArray(
  													[
  														$mdgriffith$elm_ui$Element$text('\u00A0')
  													]);
  											} else {
  												var place = _v1.a;
  												return _List_fromArray(
  													[
  														A3($mdgriffith$elm_ui$Element$Input$renderPlaceholder, place, _List_Nil, textOptions.ct === '')
  													]);
  											}
  										} else {
  											return _List_fromArray(
  												[
  													$mdgriffith$elm_ui$Internal$Model$unstyled(
  													A2(
  														$elm$html$Html$span,
  														_List_fromArray(
  															[
  																$elm$html$Html$Attributes$class($mdgriffith$elm_ui$Internal$Style$classes.dy)
  															]),
  														_List_fromArray(
  															[
  																$elm$html$Html$text(textOptions.ct + '\u00A0')
  															])))
  												]);
  										}
  									}()))
  							])));
  			} else {
  				var inputType = _v0.a;
  				return A4(
  					$mdgriffith$elm_ui$Internal$Model$element,
  					$mdgriffith$elm_ui$Internal$Model$asEl,
  					$mdgriffith$elm_ui$Internal$Model$div,
  					A2(
  						$elm$core$List$cons,
  						$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  						A2(
  							$elm$core$List$cons,
  							A2($elm$core$List$any, $mdgriffith$elm_ui$Element$Input$hasFocusStyle, withDefaults) ? $mdgriffith$elm_ui$Internal$Model$NoAttribute : $mdgriffith$elm_ui$Internal$Model$htmlClass($mdgriffith$elm_ui$Internal$Style$classes.bP),
  							$elm$core$List$concat(
  								_List_fromArray(
  									[
  										redistributed.b,
  										function () {
  										var _v2 = textOptions.ce;
  										if (_v2.$ === 1) {
  											return _List_Nil;
  										} else {
  											var place = _v2.a;
  											return _List_fromArray(
  												[
  													$mdgriffith$elm_ui$Element$behindContent(
  													A3($mdgriffith$elm_ui$Element$Input$renderPlaceholder, place, redistributed.s, textOptions.ct === ''))
  												]);
  										}
  									}()
  									])))),
  					$mdgriffith$elm_ui$Internal$Model$Unkeyed(
  						_List_fromArray(
  							[inputElement])));
  			}
  		}();
  		return A3(
  			$mdgriffith$elm_ui$Element$Input$applyLabel,
  			A2(
  				$elm$core$List$cons,
  				A2($mdgriffith$elm_ui$Internal$Model$Class, $mdgriffith$elm_ui$Internal$Flag$cursor, $mdgriffith$elm_ui$Internal$Style$classes.dc),
  				A2(
  					$elm$core$List$cons,
  					$mdgriffith$elm_ui$Element$Input$isHiddenLabel(textOptions.W) ? $mdgriffith$elm_ui$Internal$Model$NoAttribute : $mdgriffith$elm_ui$Element$spacing(5),
  					A2($elm$core$List$cons, $mdgriffith$elm_ui$Element$Region$announce, redistributed.e))),
  			textOptions.W,
  			wrappedInput);
  	});
  var $mdgriffith$elm_ui$Element$Input$text = $mdgriffith$elm_ui$Element$Input$textHelper(
  	{
  		x: $elm$core$Maybe$Nothing,
  		A: false,
  		o: $mdgriffith$elm_ui$Element$Input$TextInputNode('text')
  	});
  var $author$project$CpuEmulator$viewRam = function (model) {
  	var memoryData = $elm$core$Array$toList(
  		A3($elm$core$Array$slice, 0, model.aB, model.d.O));
  	return A2(
  		$mdgriffith$elm_ui$Element$column,
  		_List_fromArray(
  			[
  				$mdgriffith$elm_ui$Element$width(
  				$mdgriffith$elm_ui$Element$px(200)),
  				$mdgriffith$elm_ui$Element$htmlAttribute(
  				A2($elm$html$Html$Attributes$style, 'height', '640px'))
  			]),
  		_List_fromArray(
  			[
  				$mdgriffith$elm_ui$Element$text('RAM'),
  				A2(
  				$author$project$CpuEmulator$indexedTable,
  				_List_fromArray(
  					[
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						$FabienHenon$elm_infinite_scroll$InfiniteScroll$infiniteScroll($author$project$CpuEmulator$RamScrollMsg)),
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						A2($elm$html$Html$Attributes$style, 'height', '640px')),
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						A2($elm$html$Html$Attributes$style, 'overflow-y', 'auto'))
  					]),
  				{
  					bb: _List_fromArray(
  						[
  							{
  							aT: $mdgriffith$elm_ui$Element$none,
  							aq: F2(
  								function (index, _v0) {
  									return A2(
  										$mdgriffith$elm_ui$Element$el,
  										_List_Nil,
  										$mdgriffith$elm_ui$Element$text(
  											$elm$core$String$fromInt(index)));
  								}),
  							aJ: $mdgriffith$elm_ui$Element$px(50)
  						},
  							{
  							aT: $mdgriffith$elm_ui$Element$none,
  							aq: F2(
  								function (index, cell) {
  									var isEditing = function () {
  										var _v1 = model.aw;
  										if (_v1.$ === 1) {
  											return false;
  										} else {
  											var editingIndex = _v1.a;
  											return _Utils_eq(index, editingIndex);
  										}
  									}();
  									var commonStyle = _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Element$paddingXY, 10, 0),
  											$mdgriffith$elm_ui$Element$Border$width(1),
  											$mdgriffith$elm_ui$Element$height(
  											$mdgriffith$elm_ui$Element$px(22)),
  											$mdgriffith$elm_ui$Element$width(
  											$mdgriffith$elm_ui$Element$px(130))
  										]);
  									var cellStyle = (!index) ? _Utils_ap(
  										commonStyle,
  										_List_fromArray(
  											[
  												$mdgriffith$elm_ui$Element$Background$color($author$project$CpuEmulator$colors.bl)
  											])) : commonStyle;
  									return A2(
  										$mdgriffith$elm_ui$Element$el,
  										cellStyle,
  										isEditing ? A2(
  											$mdgriffith$elm_ui$Element$Input$text,
  											_Utils_ap(
  												cellStyle,
  												_List_fromArray(
  													[
  														$mdgriffith$elm_ui$Element$Events$onLoseFocus(
  														$author$project$CpuEmulator$StopEditingRam(index)),
  														$mdgriffith$elm_ui$Element$htmlAttribute(
  														$elm$html$Html$Attributes$id(
  															'ram' + $elm$core$String$fromInt(index))),
  														$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
  													])),
  											{
  												W: $mdgriffith$elm_ui$Element$Input$labelHidden('edit ram'),
  												b7: $author$project$CpuEmulator$EditRam(index),
  												ce: $elm$core$Maybe$Nothing,
  												ct: $elm$core$String$fromInt(cell)
  											}) : A2(
  											$mdgriffith$elm_ui$Element$el,
  											_List_fromArray(
  												[
  													$mdgriffith$elm_ui$Element$Events$onClick(
  													$author$project$CpuEmulator$StartEditingRam(index)),
  													$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
  												]),
  											$mdgriffith$elm_ui$Element$text(
  												model.w ? $elm$core$String$fromInt(cell) : '-')));
  								}),
  							aJ: $mdgriffith$elm_ui$Element$fill
  						}
  						]),
  					bc: memoryData
  				})
  			]));
  };
  var $author$project$CpuEmulator$viewRegister = F3(
  	function (name, value, isAnimated) {
  		return A2(
  			$mdgriffith$elm_ui$Element$el,
  			_List_fromArray(
  				[
  					$mdgriffith$elm_ui$Element$Border$width(2),
  					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  					$mdgriffith$elm_ui$Element$padding(5)
  				]),
  			$mdgriffith$elm_ui$Element$text(
  				name + (' = ' + (isAnimated ? $elm$core$String$fromInt(value) : '-'))));
  	});
  var $author$project$CpuEmulator$ResetComputer = {$: 4};
  var $elm$svg$Svg$Attributes$points = _VirtualDom_attribute('points');
  var $elm$svg$Svg$polyline = $elm$svg$Svg$trustedNode('polyline');
  var $feathericons$elm_feather$FeatherIcons$chevronsLeft = A2(
  	$feathericons$elm_feather$FeatherIcons$makeBuilder,
  	'chevrons-left',
  	_List_fromArray(
  		[
  			A2(
  			$elm$svg$Svg$polyline,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$points('11 17 6 12 11 7')
  				]),
  			_List_Nil),
  			A2(
  			$elm$svg$Svg$polyline,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$points('18 17 13 12 18 7')
  				]),
  			_List_Nil)
  		]));
  var $author$project$CpuEmulator$viewResetButton = A2(
  	$mdgriffith$elm_ui$Element$Input$button,
  	$author$project$CpuEmulator$styles.ae,
  	{
  		W: $mdgriffith$elm_ui$Element$html(
  			A2($feathericons$elm_feather$FeatherIcons$toHtml, _List_Nil, $feathericons$elm_feather$FeatherIcons$chevronsLeft)),
  		az: $elm$core$Maybe$Just($author$project$CpuEmulator$ResetComputer)
  	});
  var $author$project$CpuEmulator$EditInstruction = F2(
  	function (a, b) {
  		return {$: 6, a: a, b: b};
  	});
  var $author$project$CpuEmulator$StartEditingInstruction = function (a) {
  	return {$: 5, a: a};
  };
  var $author$project$CpuEmulator$StopEditingInstruction = function (a) {
  	return {$: 7, a: a};
  };
  var $author$project$CpuEmulator$viewRom = function (model) {
  	var instructionData = $elm$core$Array$toList(
  		A3($elm$core$Array$slice, 0, model.aC, model.C));
  	return A2(
  		$mdgriffith$elm_ui$Element$column,
  		_List_fromArray(
  			[
  				$mdgriffith$elm_ui$Element$width(
  				$mdgriffith$elm_ui$Element$px(200)),
  				$mdgriffith$elm_ui$Element$htmlAttribute(
  				A2($elm$html$Html$Attributes$style, 'height', '640px'))
  			]),
  		_List_fromArray(
  			[
  				$mdgriffith$elm_ui$Element$text('ROM'),
  				A2(
  				$author$project$CpuEmulator$indexedTable,
  				_List_fromArray(
  					[
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						$FabienHenon$elm_infinite_scroll$InfiniteScroll$infiniteScroll($author$project$CpuEmulator$RomScrollMsg)),
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						A2($elm$html$Html$Attributes$style, 'height', '640px')),
  						$mdgriffith$elm_ui$Element$htmlAttribute(
  						A2($elm$html$Html$Attributes$style, 'overflow-y', 'auto'))
  					]),
  				{
  					bb: _List_fromArray(
  						[
  							{
  							aT: $mdgriffith$elm_ui$Element$none,
  							aq: F2(
  								function (index, _v0) {
  									return A2(
  										$mdgriffith$elm_ui$Element$el,
  										_List_Nil,
  										$mdgriffith$elm_ui$Element$text(
  											$elm$core$String$fromInt(index)));
  								}),
  							aJ: $mdgriffith$elm_ui$Element$px(50)
  						},
  							{
  							aT: $mdgriffith$elm_ui$Element$none,
  							aq: F2(
  								function (index, cell) {
  									var isEditing = function () {
  										var _v3 = model.av;
  										if (_v3.$ === 1) {
  											return false;
  										} else {
  											var editingIndex = _v3.a;
  											return _Utils_eq(index, editingIndex);
  										}
  									}();
  									var commonStyle = _List_fromArray(
  										[
  											A2($mdgriffith$elm_ui$Element$paddingXY, 10, 0),
  											$mdgriffith$elm_ui$Element$Border$width(1),
  											$mdgriffith$elm_ui$Element$height(
  											$mdgriffith$elm_ui$Element$px(22)),
  											$mdgriffith$elm_ui$Element$width(
  											$mdgriffith$elm_ui$Element$px(130)),
  											$mdgriffith$elm_ui$Element$htmlAttribute(
  											$elm$html$Html$Attributes$id(
  												'instruction' + $elm$core$String$fromInt(index)))
  										]);
  									var cellStyle = function (previousStyle) {
  										var _v1 = model.d.K;
  										if (_v1.$ === 1) {
  											return previousStyle;
  										} else {
  											var _v2 = _v1.a;
  											var location = _v2.a;
  											return _Utils_eq(location, index) ? _Utils_ap(
  												previousStyle,
  												_List_fromArray(
  													[
  														$mdgriffith$elm_ui$Element$Background$color($author$project$CpuEmulator$colors.b1)
  													])) : previousStyle;
  										}
  									}(
  										(model.w && _Utils_eq(index, model.d.l)) ? _Utils_ap(
  											commonStyle,
  											_List_fromArray(
  												[
  													$mdgriffith$elm_ui$Element$Background$color($author$project$CpuEmulator$colors.bl)
  												])) : commonStyle);
  									return A2(
  										$mdgriffith$elm_ui$Element$el,
  										cellStyle,
  										isEditing ? A2(
  											$mdgriffith$elm_ui$Element$Input$text,
  											_Utils_ap(
  												cellStyle,
  												_List_fromArray(
  													[
  														$mdgriffith$elm_ui$Element$Events$onLoseFocus(
  														$author$project$CpuEmulator$StopEditingInstruction(index))
  													])),
  											{
  												W: $mdgriffith$elm_ui$Element$Input$labelHidden('edit instruction'),
  												b7: $author$project$CpuEmulator$EditInstruction(index),
  												ce: $elm$core$Maybe$Nothing,
  												ct: cell
  											}) : A2(
  											$mdgriffith$elm_ui$Element$el,
  											_List_fromArray(
  												[
  													$mdgriffith$elm_ui$Element$Events$onClick(
  													$author$project$CpuEmulator$StartEditingInstruction(index)),
  													$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill)
  												]),
  											$mdgriffith$elm_ui$Element$text(cell)));
  								}),
  							aJ: $mdgriffith$elm_ui$Element$fill
  						}
  						]),
  					bc: instructionData
  				})
  			]));
  };
  var $author$project$CpuEmulator$StartRunningComputer = {$: 2};
  var $author$project$CpuEmulator$StopRunningComputer = {$: 3};
  var $feathericons$elm_feather$FeatherIcons$chevronsRight = A2(
  	$feathericons$elm_feather$FeatherIcons$makeBuilder,
  	'chevrons-right',
  	_List_fromArray(
  		[
  			A2(
  			$elm$svg$Svg$polyline,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$points('13 17 18 12 13 7')
  				]),
  			_List_Nil),
  			A2(
  			$elm$svg$Svg$polyline,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$points('6 17 11 12 6 7')
  				]),
  			_List_Nil)
  		]));
  var $elm$svg$Svg$rect = $elm$svg$Svg$trustedNode('rect');
  var $elm$svg$Svg$Attributes$x = _VirtualDom_attribute('x');
  var $elm$svg$Svg$Attributes$y = _VirtualDom_attribute('y');
  var $feathericons$elm_feather$FeatherIcons$pause = A2(
  	$feathericons$elm_feather$FeatherIcons$makeBuilder,
  	'pause',
  	_List_fromArray(
  		[
  			A2(
  			$elm$svg$Svg$rect,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$x('6'),
  					$elm$svg$Svg$Attributes$y('4'),
  					$elm$svg$Svg$Attributes$width('4'),
  					$elm$svg$Svg$Attributes$height('16')
  				]),
  			_List_Nil),
  			A2(
  			$elm$svg$Svg$rect,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$x('14'),
  					$elm$svg$Svg$Attributes$y('4'),
  					$elm$svg$Svg$Attributes$width('4'),
  					$elm$svg$Svg$Attributes$height('16')
  				]),
  			_List_Nil)
  		]));
  var $author$project$CpuEmulator$viewRunButton = function (isRunningComputer) {
  	return A2(
  		$mdgriffith$elm_ui$Element$Input$button,
  		$author$project$CpuEmulator$styles.ae,
  		{
  			W: $mdgriffith$elm_ui$Element$html(
  				A2(
  					$feathericons$elm_feather$FeatherIcons$toHtml,
  					_List_Nil,
  					isRunningComputer ? $feathericons$elm_feather$FeatherIcons$pause : $feathericons$elm_feather$FeatherIcons$chevronsRight)),
  			az: isRunningComputer ? $elm$core$Maybe$Just($author$project$CpuEmulator$StopRunningComputer) : $elm$core$Maybe$Just($author$project$CpuEmulator$StartRunningComputer)
  		});
  };
  var $author$project$CpuEmulator$StepComputer = {$: 1};
  var $feathericons$elm_feather$FeatherIcons$chevronRight = A2(
  	$feathericons$elm_feather$FeatherIcons$makeBuilder,
  	'chevron-right',
  	_List_fromArray(
  		[
  			A2(
  			$elm$svg$Svg$polyline,
  			_List_fromArray(
  				[
  					$elm$svg$Svg$Attributes$points('9 18 15 12 9 6')
  				]),
  			_List_Nil)
  		]));
  var $author$project$CpuEmulator$viewSingleStepButton = A2(
  	$mdgriffith$elm_ui$Element$Input$button,
  	$author$project$CpuEmulator$styles.ae,
  	{
  		W: $mdgriffith$elm_ui$Element$html(
  			A2($feathericons$elm_feather$FeatherIcons$toHtml, _List_Nil, $feathericons$elm_feather$FeatherIcons$chevronRight)),
  		az: $elm$core$Maybe$Just($author$project$CpuEmulator$StepComputer)
  	});
  var $author$project$CpuEmulator$view = function (model) {
  	return A2(
  		$mdgriffith$elm_ui$Element$layout,
  		_List_fromArray(
  			[
  				$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  				$mdgriffith$elm_ui$Element$height($mdgriffith$elm_ui$Element$fill),
  				$mdgriffith$elm_ui$Element$padding(20),
  				$mdgriffith$elm_ui$Element$Font$family(
  				_List_fromArray(
  					[
  						$mdgriffith$elm_ui$Element$Font$typeface('Roboto Mono'),
  						$mdgriffith$elm_ui$Element$Font$monospace
  					]))
  			]),
  		A2(
  			$mdgriffith$elm_ui$Element$row,
  			_List_fromArray(
  				[
  					$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  					$mdgriffith$elm_ui$Element$spacing(20)
  				]),
  			_List_fromArray(
  				[
  					A2(
  					$mdgriffith$elm_ui$Element$column,
  					_List_fromArray(
  						[
  							$mdgriffith$elm_ui$Element$spacing(20),
  							$mdgriffith$elm_ui$Element$alignTop
  						]),
  					_List_fromArray(
  						[
  							$author$project$CpuEmulator$viewRam(model),
  							A2(
  							$mdgriffith$elm_ui$Element$column,
  							_List_fromArray(
  								[
  									$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  									$mdgriffith$elm_ui$Element$spacing(10)
  								]),
  							_List_fromArray(
  								[
  									A3($author$project$CpuEmulator$viewRegister, 'A', model.d.r, model.w),
  									A3($author$project$CpuEmulator$viewRegister, 'D', model.d.ag, model.w),
  									A3($author$project$CpuEmulator$viewRegister, 'M', model.d.X, model.w)
  								]))
  						])),
  					A2(
  					$mdgriffith$elm_ui$Element$column,
  					_List_fromArray(
  						[
  							$mdgriffith$elm_ui$Element$spacing(20),
  							$mdgriffith$elm_ui$Element$alignTop
  						]),
  					_List_fromArray(
  						[
  							$author$project$CpuEmulator$viewRom(model),
  							A2(
  							$mdgriffith$elm_ui$Element$column,
  							_List_fromArray(
  								[
  									$mdgriffith$elm_ui$Element$width($mdgriffith$elm_ui$Element$fill),
  									$mdgriffith$elm_ui$Element$spacing(10),
  									$mdgriffith$elm_ui$Element$onRight(
  									$author$project$CpuEmulator$viewAssemblerErrorMessage(model.d.K))
  								]),
  							_List_fromArray(
  								[
  									A3($author$project$CpuEmulator$viewRegister, 'PC', model.d.l, model.w),
  									A2(
  									$mdgriffith$elm_ui$Element$row,
  									_List_fromArray(
  										[
  											$mdgriffith$elm_ui$Element$spacing(20)
  										]),
  									_List_fromArray(
  										[
  											$author$project$CpuEmulator$viewSingleStepButton,
  											$author$project$CpuEmulator$viewRunButton(model.V),
  											$author$project$CpuEmulator$viewResetButton
  										])),
  									A2(
  									$mdgriffith$elm_ui$Element$row,
  									_List_fromArray(
  										[
  											$mdgriffith$elm_ui$Element$spacing(20)
  										]),
  									_List_fromArray(
  										[
  											$author$project$CpuEmulator$viewEditButton(model.d)
  										]))
  								]))
  						])),
  					$author$project$CpuEmulator$viewCloseEditorButton(model.ai)
  				])));
  };
  var $author$project$CpuEmulator$main = $elm$browser$Browser$element(
  	{dw: $author$project$CpuEmulator$init, d8: $author$project$CpuEmulator$subscriptions, et: $author$project$CpuEmulator$update, aq: $author$project$CpuEmulator$view});
  _Platform_export({'CpuEmulator':{'init':$author$project$CpuEmulator$main(
  	$elm$json$Json$Decode$succeed(0))(0)}});}(this));