From 38adda8f04411ce795c536254d8273069b427a16 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Mon, 24 Aug 2015 16:54:23 -0400 Subject: [PATCH 1/9] file-uploader example: draft - top-level update uses [state, [futures]] updates - unit tests using dummy uploader --- examples/file-uploader/js/app.js | 73 + examples/file-uploader/js/list.js | 76 + examples/file-uploader/js/main.js | 31 + examples/file-uploader/js/svg.js | 8 + examples/file-uploader/js/test.js | 271 + examples/file-uploader/js/test_build.js | 15742 ++++++++++++++++++++++ examples/file-uploader/js/upload.js | 176 + examples/file-uploader/js/uploader.js | 61 + examples/file-uploader/package.json | 29 + 9 files changed, 16467 insertions(+) create mode 100644 examples/file-uploader/js/app.js create mode 100644 examples/file-uploader/js/list.js create mode 100644 examples/file-uploader/js/main.js create mode 100644 examples/file-uploader/js/svg.js create mode 100644 examples/file-uploader/js/test.js create mode 100644 examples/file-uploader/js/test_build.js create mode 100644 examples/file-uploader/js/upload.js create mode 100644 examples/file-uploader/js/uploader.js create mode 100644 examples/file-uploader/package.json diff --git a/examples/file-uploader/js/app.js b/examples/file-uploader/js/app.js new file mode 100644 index 0000000..c43727f --- /dev/null +++ b/examples/file-uploader/js/app.js @@ -0,0 +1,73 @@ +const Type = require('union-type'); +const T = require('ramda/src/T') + , evolve = require('ramda/src/evolve') + , curry = require('ramda/src/curry') + , map = require('ramda/src/map') + , invoker = require('ramda/src/invoker') +; +const h = require('snabbdom/h'); + +const uploadList = require('./list'); +const uploader = require('./uploader'); + + +// action + +const listUpdate = (listAction,model) => { + const [state, tasks] = uploadList.update(listAction); + return [ evolve({uploads: state},model), + tasks.map( map(Action.Route) ) + ]; +} + +const Action = Type({ + Create: [Function,Array], + Route: [uploadList.Action] +}); + +const update = Action.caseOn({ + Create: (up,files,model) => { + return listUpdate( uploadList.Action.Create(up,files), model ); + }, + + Route: listUpdate +}); + + +// model + +const init = () = { uploads: uploadList.init() } + +// view + +const view = curry( ({url, headers, action$}, model) => { + + const up = uploader.upload(headers, url); + + const form = ( + h('form', {on: {submit: preventDefault} }, [ + h('input', + { attr: {'type': 'file'}, + on: { + change: compose(action$, Action.Create(up), getTarget('files')) + } + } + ) + ] + ) + ); + + return ( + h('div.uploading', {}, [ + form, + uploadList.view(model.uploads) + ]) + ); +}); + +const getTarget = curry( (key,e) => e.target[key] ); +const preventDefault = invoker(0, 'preventDefault'); + + +module.exports = { init, update, Action, view } + diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js new file mode 100644 index 0000000..a7e0747 --- /dev/null +++ b/examples/file-uploader/js/list.js @@ -0,0 +1,76 @@ +const Type = require('union-type'); +const T = require('ramda/src/T') + , adjust = require('ramda/src/adjust') + , append = require('ramda/src/append') + , curry = require('ramda/src/curry') +; +const h = require('snabbdom/h'); + +const upload = require('./upload'); +const uploader = require('./uploader'); + +const sync = (s) => [s, []]; + +// action + +const Action = Type({ + Create: [Function, Array], + Result: [Number, uploader.Result] +}); + +const update = Action.caseOn({ + + Create: (up,files,model) => { + const idx = nextIndex(model); + const task = up(files); + const taskAction = Action.Result(idx); + const newState = append( upload.init(files), model); + return [newState, [task.map(taskAction)]]; + }, + + Result: (i,result,model) => { + const finish = (type) => () => { + return adjust(upload.update(upload.Action[type]()), i, model); + }; + return sync( + uploader.Result.case({ + OK: finish('Uploaded'), + NotFound: finish('Error'), + Error: finish('Error'), + Abort: finish('Abort'), + Progress: (p,abort) => { + return adjust(upload.update(upload.Action.Progress(p,abort)), i, model); + } + }, result) + ); + } + +}); + + +// model + +const init = () => [] +const nextIndex = (model) => model.length; + +// view + +const view = (model) => { + + const listItemView = (item, i) => { + const view = upload.view( + { progress: { height: 20, weight: 200 } }, + item + ); + return h('li', {}, view); + } + + return ( + h('ul', {}, model.map( listItemView ) ) + ); + +}; + + +module.exports = { init, update, Action, view } + diff --git a/examples/file-uploader/js/main.js b/examples/file-uploader/js/main.js new file mode 100644 index 0000000..c2d5396 --- /dev/null +++ b/examples/file-uploader/js/main.js @@ -0,0 +1,31 @@ +/* globals: document, window */ + +const map = require('ramda/src/map'); +const patch = require('snabbdom').init([ + require('snabbdom/modules/class'), + require('snabbdom/modules/style'), + require('snabbdom/modules/props'), + require('snabbdom/modules/eventlisteners') +]); + +const app = require('./app'); +const uploader = require('./uploader); + +let state = app.init(), asyncActions, vnode + +const render = () => { + vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state)); +}; + +const update = (action) => { + [state, asyncActions] = app.update(action, state); + map((a) => a.fork((err) => {throw err}, update), asyncActions); + console.log(state); + render(); +}; + +window.addEventListener('DOMContentLoaded', () => { + vnode = document.getElementById('container'); + render(); +}); + diff --git a/examples/file-uploader/js/svg.js b/examples/file-uploader/js/svg.js new file mode 100644 index 0000000..66d9b08 --- /dev/null +++ b/examples/file-uploader/js/svg.js @@ -0,0 +1,8 @@ +const h = require('snabbdom/h'); + +module.exports = function svg(...args){ + const vnode = h(...args); + vnode.data.ns = 'http://www.w3.org/2000/svg'; + return vnode; +} + diff --git a/examples/file-uploader/js/test.js b/examples/file-uploader/js/test.js new file mode 100644 index 0000000..e90c641 --- /dev/null +++ b/examples/file-uploader/js/test.js @@ -0,0 +1,271 @@ +const tape = require('tape') + , test = tape.test; + +const compose = require('ramda/src/compose'); +const curry = require('ramda/src/curry'); +const map = require('ramda/src/map'); +const all = require('ramda/src/all'); +const zip = require('ramda/src/zip'); + +const Future = require('ramda-fantasy/src/Future'); + +const upload = require('./upload'); +const uploadList = require('./list'); +const uploader = require('./uploader'); + +const noop = function(){} + +/******************************************************************************/ +const progressUpload = (total, loaded, data) => { + return upload.update( upload.Action.Progress({total,loaded},noop), data ); +} + +const finishUpload = upload.update(upload.Action.Uploaded()); + +test('upload component, single file', (assert) => { + + let subject = upload.init([{ name: 'GreatAmericanNovel.pdf', + type: 'application/pdf'} + ]); + assert.equal(subject.status, 'initial', 'initial status'); + assert.equal(subject.title, 'GreatAmericanNovel.pdf', 'title'); + + subject = progressUpload(100, 1, subject); + assert.equal(subject.status, 'uploading', + 'uploading status after progress action 1'); + assert.equal(subject.progress.loaded, 1, 'loaded'); + assert.equal(subject.progress.total, 100, 'total'); + + subject = progressUpload(100, 65.4321, subject); + assert.equal(subject.status, 'uploading', + 'uploading status after progress action 65.4321'); + assert.equal(subject.progress.loaded, 65.4321, 'loaded non-integer'); + assert.equal(subject.progress.total, 100, 'total'); + + subject = progressUpload(100, 100, subject); + assert.equal(subject.status, 'processing', + 'processing status after progress action 100'); + + subject = finishUpload(subject); + assert.equal(subject.status, 'uploaded', + 'uploaded status after uploaded action'); + + assert.end(); +}); + +test('upload component, multiple files', (assert) => { + + let subject = upload.init([ + { name: 'chapter1.txt', type: 'text/plain' }, + { name: 'chapter2.txt', type: 'text/plain' }, + { name: 'chapter3.txt', type: 'text/plain' } + ]); + + assert.equal(subject.title, '(3 files)', 'title indicates 3 files'); + + assert.end(); +}); + + +/******************************************************************************/ + +const dummyUploader = curry( (total, steps, abort, final, files) => { + return new Future( (rej, res) => { + + const progress = (loaded, delay) => { + delay = delay + ( Math.random() * 2000 ); + setTimeout( + () => res(uploader.Result.Progress({total,loaded},abort)), + delay + ); + return delay; + } + + const delay = steps.reduce( (delay,step) => progress(step,delay), 0); + + if (final){ + setTimeout( + () => res(final({})), + delay + ( Math.random() * 2000 ) + ); + } + + }); +}); + + +test('upload list component, add file list, progress', (assert) => { + assert.plan(4 + 4); + + let subject = uploadList.init(), tasks, snapshots = []; + + const update = (action) => { + [subject, tasks] = uploadList.update(action, subject); + map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks); + snapshots.push(subject); + console.log(subject); + } + + const steps = [1,3,10,19,100]; + const up = dummyUploader(100, steps, noop, null); + + update( + uploadList.Action.Create(up, [ + { name: 'chapter1.txt', type: 'text/plain' }, + { name: 'chapter2.txt', type: 'text/plain' }, + { name: 'chapter3.txt', type: 'text/plain' } + ]) + ); + + assert.equal(subject.length, 1, 'upload list has 1 file list'); + assert.equal(subject[0].files.length, 3, '3 files in group'); + assert.equal(subject[0].title, '(3 files)', 'title indicates 3 files'); + assert.equal(subject[0].status, 'initial', 'initial status'); + + setTimeout( () => { + + assert.equal(snapshots.length, steps.length + 1, + '1 initial transition + 1 per expected progress step'); + + assert.ok( all( (s) => s[0].status == 'uploading', snapshots.slice(1,-1)), + 'uploading status after each progress step except the last'); + + assert.ok( all( (s) => s[0].status == 'processing', snapshots.slice(-1)), + 'processing status after loaded 100% of total (last step)'); + + assert.ok( all( ([step,s]) => s[0].progress.loaded === step, + zip(steps, snapshots.slice(1))), + 'expected loading progress at each progress step'); + }, + (steps.length)*2000 // max time for steps to complete + ); + +}); + +test('upload list component, add two file lists, progress independently', (assert) => { + assert.plan(1); + + let subject = uploadList.init(), tasks, snapshots = []; + + const update = (action) => { + [subject, tasks] = uploadList.update(action, subject); + map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks); + snapshots.push(subject); + console.log(subject); + } + + const trigger = (up, files, delay) => { + setTimeout( () => { + update( + uploadList.Action.Create(up, files) + ); + }, + delay + ); + } + + const steps1 = [1, 23,34,45,56,67,78,99,100]; + const steps2 = [22,34,46,59,78,100]; + + const up1 = dummyUploader(100, steps1, noop, uploader.Result.OK); + const up2 = dummyUploader(100, steps2, noop, uploader.Result.OK); + + trigger( up1, + [ {name: 'first.png', type: 'image/png'} ], + Math.random() * 2000 ); + + trigger( up2, + [ {name: 'second.png', type: 'image/png'} ], + Math.random() * 2000 ); + + setTimeout( () => { + const exp = 2 + steps1.length + steps2.length + 2; + assert.equal(snapshots.length, exp, + '' + exp + ' == ' + + '1 initial transition per file list + ' + + '1 per expected progress step + ' + + '1 final transition per file list'); + + }, + (4 + Math.max(steps1.length,steps2.length)) * 2000 // max time for steps to complete + ); + +}); + +test('upload list component, add file list, result ok', (assert) => { + assert.plan(2); + + let subject = uploadList.init(), tasks, snapshots = []; + + const update = (action) => { + [subject, tasks] = uploadList.update(action, subject); + map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks); + snapshots.push(subject); + console.log(subject); + } + + const steps = []; + const up = dummyUploader(100, steps, noop, uploader.Result.OK); + + update( + uploadList.Action.Create(up, [ + { name: 'chapter1.txt', type: 'text/plain' }, + { name: 'chapter2.txt', type: 'text/plain' }, + { name: 'chapter3.txt', type: 'text/plain' } + ]) + ); + + setTimeout( () => { + + assert.equal(snapshots.length, 1 + 1, + '1 initial transition + 1 for result'); + + assert.equal(snapshots[1][0].status, 'uploaded', + 'status uploaded after result OK'); + + }, + 2000 + ); + +}); + +test('upload list component, add file list, result error', (assert) => { + assert.plan(2); + + let subject = uploadList.init(), tasks, snapshots = []; + + const update = (action) => { + [subject, tasks] = uploadList.update(action, subject); + map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks); + snapshots.push(subject); + console.log(subject); + } + + const steps = []; + const up = dummyUploader(100, steps, noop, uploader.Result.Error); + + update( + uploadList.Action.Create(up, [ + { name: 'chapter1.txt', type: 'text/plain' }, + { name: 'chapter2.txt', type: 'text/plain' }, + { name: 'chapter3.txt', type: 'text/plain' } + ]) + ); + + setTimeout( () => { + + assert.equal(snapshots.length, 1 + 1, + '1 initial transition + 1 for result'); + + assert.equal(snapshots[1][0].status, 'error', + 'status uploaded after result error'); + + }, + 2000 + ); + +}); + + + + diff --git a/examples/file-uploader/js/test_build.js b/examples/file-uploader/js/test_build.js new file mode 100644 index 0000000..a198127 --- /dev/null +++ b/examples/file-uploader/js/test_build.js @@ -0,0 +1,15742 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 0 && uploading(model) ? [rect, line] : [])]); +} + +function renderStatus(model) { + var label = statusLabel(model); + return h('span', {}, label); +} + +function renderAbort(model) { + var label = actionLabel('abort'); + return h('a', { style: visible(abortable, model), + on: { click: model.abort } }, label); +} + +function visible(pred, model) { + return { display: pred(model) ? null : 'none' }; +} + +module.exports = { init: init, Action: Action, update: update, view: view }; + +},{"./svg":2,"ramda/src/always":12,"ramda/src/curry":16,"ramda/src/evolve":18,"ramda/src/find":19,"ramda/src/map":43,"ramda/src/merge":44,"ramda/src/reduce":46,"snabbdom/h":51,"union-type":73}],5:[function(require,module,exports){ +/* globals XMLHttpRequest, FormData */ + +'use strict'; + +var compose = require('ramda/src/compose'), + __ = require('ramda/src/__'), + curry = require('ramda/src/curry'); +var Type = require('union-type'); +var Future = require('ramda-fantasy/src/Future'); + +var identity = function identity(x) { + return x; +}; + +var Result = Type({ + OK: [Object], + NotFound: [Object], + Error: [Object], + Abort: [Object], + Unknown: [Object], + Progress: [Object, Function] +}); + +var upload = curry(function (headers, url, files) { + headers = headers || {}; + progress = progress || identity; + + return new Future(function (rej, res) { + var xhr = new XMLHttpRequest(); + var getxhr = always(xhr); + var abort = xhr.abort.bind(xhr); + xhr.addEventListener('load', compose(res, deriveResult, getxhr), false); + xhr.addEventListener('abort', compose(res, Result.Abort, getxhr), false); + xhr.addEventListener('error', compose(res, Result.Error, getxhr), false); + + xhr.upload.addEventListener('progress', compose(res, Result.Progress(__, abort)), false); + + xhr.open('post', url, true); + for (k in headers) { + xhr.setRequestHeader(k, headers[k]); + } + xhr.send(formdata(files)); + }); +}); + +module.exports = { upload: upload, Result: Result }; + +function deriveResult(xhr) { + return xhr.status < 400 ? Result.OK : xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : xhr.status >= 500 ? Result.Error : Result.Unknown; +} + +function formdata(files) { + var data = new FormData(); + for (var i = 0; i < files.length; ++i) { + data.append(files[i].name, files[i]); + }return data; +} + +},{"ramda-fantasy/src/Future":6,"ramda/src/__":9,"ramda/src/compose":15,"ramda/src/curry":16,"union-type":73}],6:[function(require,module,exports){ +var R = require('ramda'); + +// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success) +function Future(f) { + if (!(this instanceof Future)) { + return new Future(f); + } + this._fork = f; +} + +Future.prototype.fork = function(reject, resolve) { + try { + this._fork(reject, resolve); + } catch(e) { + reject(e); + } +}; + +// functor +Future.prototype.map = function(f) { + return this.chain(function(a) { return Future.of(f(a)); }); +}; + +// apply +Future.prototype.ap = function(m) { + var self = this; + + return new Future(function(rej, res) { + var applyFn, val; + var doReject = R.once(rej); + + function resolveIfDone() { + if (applyFn != null && val != null) { + return res(applyFn(val)); + } + } + + self.fork(doReject, function(fn) { + applyFn = fn; + resolveIfDone(); + }); + + m.fork(doReject, function(v) { + val = v; + resolveIfDone(); + }); + + }); + +}; + +// applicative +Future.of = function(x) { + // should include a default rejection? + return new Future(function(_, resolve) { return resolve(x); }); +}; + +Future.prototype.of = Future.of; + +// chain +// f must be a function which returns a value +// f must return a value of the same Chain +// chain must return a value of the same Chain +//:: Future a, b => (b -> Future c) -> Future c +Future.prototype.chain = function(f) { // Sorella's: + return new Future(function(reject, resolve) { + return this.fork(function(a) { return reject(a); }, + function(b) { return f(b).fork(reject, resolve); }); + }.bind(this)); +}; + +// chainReject +// Like chain but operates on the reject instead of the resolve case. +//:: Future a, b => (a -> Future c) -> Future c +Future.prototype.chainReject = function(f) { + return new Future(function(reject, resolve) { + return this.fork(function(a) { return f(a).fork(reject, resolve); }, + function(b) { return resolve(b); + }); + }.bind(this)); +}; + +// monad +// A value that implements the Monad specification must also implement the Applicative and Chain specifications. +// see above. + +Future.prototype.bimap = function(errFn, successFn) { + var self = this; + return new Future(function(reject, resolve) { + self.fork(function(err) { + reject(errFn(err)); + }, function(val) { + resolve(successFn(val)); + }); + }); +}; + +Future.reject = function(val) { + return new Future(function(reject) { + reject(val); + }); +}; + +Future.prototype.toString = function() { + return 'Future(' + R.toString(this._fork) + ')'; +}; + +Future.memoize = function(f) { + var status = 'IDLE'; + var listeners = []; + var cachedValue; + + var handleCompletion = R.curry(function(newStatus, cb, val) { + status = newStatus; + cachedValue = val; + cb(val); + R.forEach(function(listener) { + listener[status](cachedValue); + }, listeners); + }); + + function addListeners(reject, resolve) { + listeners.push({ REJECTED: reject, RESOLVED: resolve } ); + } + + function doResolve(reject, resolve) { + status = 'PENDING'; + return f.fork( + handleCompletion('REJECTED', reject), + handleCompletion('RESOLVED', resolve) + ); + } + + return new Future(function(reject, resolve) { + + switch(status) { + case 'IDLE': doResolve(reject, resolve); break; + case 'PENDING': addListeners(reject, resolve); break; + case 'REJECTED': reject(cachedValue); break; + case 'RESOLVED': resolve(cachedValue); break; + } + + }); +}; + +module.exports = Future; + +},{"ramda":7}],7:[function(require,module,exports){ +// Ramda v0.17.1 +// https://github.com/ramda/ramda +// (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers +// Ramda may be freely distributed under the MIT license. + +;(function() { + + 'use strict'; + + /** + * A special placeholder value used to specify "gaps" within curried functions, + * allowing partial application of any combination of arguments, + * regardless of their positions. + * + * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2, _)(1, 3)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @constant + * @memberOf R + * @category Function + * @example + * + * var greet = R.replace('{name}', R.__, 'Hello, {name}!'); + * greet('Alice'); //=> 'Hello, Alice!' + */ + var __ = { '@@functional/placeholder': true }; + + // jshint unused:vars + var _arity = function _arity(n, fn) { + // jshint unused:vars + switch (n) { + case 0: + return function () { + return fn.apply(this, arguments); + }; + case 1: + return function (a0) { + return fn.apply(this, arguments); + }; + case 2: + return function (a0, a1) { + return fn.apply(this, arguments); + }; + case 3: + return function (a0, a1, a2) { + return fn.apply(this, arguments); + }; + case 4: + return function (a0, a1, a2, a3) { + return fn.apply(this, arguments); + }; + case 5: + return function (a0, a1, a2, a3, a4) { + return fn.apply(this, arguments); + }; + case 6: + return function (a0, a1, a2, a3, a4, a5) { + return fn.apply(this, arguments); + }; + case 7: + return function (a0, a1, a2, a3, a4, a5, a6) { + return fn.apply(this, arguments); + }; + case 8: + return function (a0, a1, a2, a3, a4, a5, a6, a7) { + return fn.apply(this, arguments); + }; + case 9: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) { + return fn.apply(this, arguments); + }; + case 10: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return fn.apply(this, arguments); + }; + default: + throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); + } + }; + + var _cloneRegExp = function _cloneRegExp(pattern) { + return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : '')); + }; + + var _complement = function _complement(f) { + return function () { + return !f.apply(this, arguments); + }; + }; + + /** + * Private `concat` function to merge two array-like objects. + * + * @private + * @param {Array|Arguments} [set1=[]] An array-like object. + * @param {Array|Arguments} [set2=[]] An array-like object. + * @return {Array} A new, merged array. + * @example + * + * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + */ + var _concat = function _concat(set1, set2) { + set1 = set1 || []; + set2 = set2 || []; + var idx; + var len1 = set1.length; + var len2 = set2.length; + var result = []; + idx = 0; + while (idx < len1) { + result[result.length] = set1[idx]; + idx += 1; + } + idx = 0; + while (idx < len2) { + result[result.length] = set2[idx]; + idx += 1; + } + return result; + }; + + var _containsWith = function _containsWith(pred, x, list) { + var idx = 0, len = list.length; + while (idx < len) { + if (pred(x, list[idx])) { + return true; + } + idx += 1; + } + return false; + }; + + /** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry1 = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn.apply(this, arguments); + } + }; + }; + + /** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry2 = function _curry2(fn) { + return function f2(a, b) { + var n = arguments.length; + if (n === 0) { + return f2; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f2; + } else if (n === 1) { + return _curry1(function (b) { + return fn(a, b); + }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return f2; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function (a) { + return fn(a, b); + }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function (b) { + return fn(a, b); + }); + } else { + return fn(a, b); + } + }; + }; + + /** + * Optimized internal three-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry3 = function _curry3(fn) { + return function f3(a, b, c) { + var n = arguments.length; + if (n === 0) { + return f3; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f3; + } else if (n === 1) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return f3; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry2(function (a, c) { + return fn(a, b, c); + }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 2) { + return _curry1(function (c) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return f3; + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function (a, b) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return _curry2(function (a, c) { + return fn(a, b, c); + }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function (a) { + return fn(a, b, c); + }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function (b) { + return fn(a, b, c); + }); + } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) { + return _curry1(function (c) { + return fn(a, b, c); + }); + } else { + return fn(a, b, c); + } + }; + }; + + /** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ + var _curryN = function _curryN(length, received, fn) { + return function () { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn)); + }; + }; + + var _filter = function _filter(fn, list) { + var idx = 0, len = list.length, result = []; + while (idx < len) { + if (fn(list[idx])) { + result[result.length] = list[idx]; + } + idx += 1; + } + return result; + }; + + var _forceReduced = function _forceReduced(x) { + return { + '@@transducer/value': x, + '@@transducer/reduced': true + }; + }; + + /** + * @private + * @param {Function} fn The strategy for extracting function names from an object + * @return {Function} A function that takes an object and returns an array of function names. + */ + var _functionsWith = function _functionsWith(fn) { + return function (obj) { + return _filter(function (key) { + return typeof obj[key] === 'function'; + }, fn(obj)); + }; + }; + + var _has = function _has(prop, obj) { + return Object.prototype.hasOwnProperty.call(obj, prop); + }; + + var _identity = function _identity(x) { + return x; + }; + + /** + * Tests whether or not an object is an array. + * + * @private + * @param {*} val The object to test. + * @return {Boolean} `true` if `val` is an array, `false` otherwise. + * @example + * + * _isArray([]); //=> true + * _isArray(null); //=> false + * _isArray({}); //=> false + */ + var _isArray = Array.isArray || function _isArray(val) { + return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]'; + }; + + /** + * Determine if the passed argument is an integer. + * + * @private + * @param {*} n + * @category Type + * @return {Boolean} + */ + var _isInteger = Number.isInteger || function _isInteger(n) { + return n << 0 === n; + }; + + var _isNumber = function _isNumber(x) { + return Object.prototype.toString.call(x) === '[object Number]'; + }; + + var _isString = function _isString(x) { + return Object.prototype.toString.call(x) === '[object String]'; + }; + + var _isTransformer = function _isTransformer(obj) { + return typeof obj['@@transducer/step'] === 'function'; + }; + + var _map = function _map(fn, list) { + var idx = 0, len = list.length, result = Array(len); + while (idx < len) { + result[idx] = fn(list[idx]); + idx += 1; + } + return result; + }; + + var _pipe = function _pipe(f, g) { + return function () { + return g.call(this, f.apply(this, arguments)); + }; + }; + + var _pipeP = function _pipeP(f, g) { + return function () { + var ctx = this; + return f.apply(ctx, arguments).then(function (x) { + return g.call(ctx, x); + }); + }; + }; + + var _quote = function _quote(s) { + return '"' + s.replace(/"/g, '\\"') + '"'; + }; + + var _reduced = function _reduced(x) { + return x && x['@@transducer/reduced'] ? x : { + '@@transducer/value': x, + '@@transducer/reduced': true + }; + }; + + /** + * An optimized, private array `slice` implementation. + * + * @private + * @param {Arguments|Array} args The array or arguments object to consider. + * @param {Number} [from=0] The array index to slice from, inclusive. + * @param {Number} [to=args.length] The array index to slice to, exclusive. + * @return {Array} A new, sliced array. + * @example + * + * _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3] + * + * var firstThreeArgs = function(a, b, c, d) { + * return _slice(arguments, 0, 3); + * }; + * firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3] + */ + var _slice = function _slice(args, from, to) { + switch (arguments.length) { + case 1: + return _slice(args, 0, args.length); + case 2: + return _slice(args, from, args.length); + default: + var list = []; + var idx = 0; + var len = Math.max(0, Math.min(args.length, to) - from); + while (idx < len) { + list[idx] = args[from + idx]; + idx += 1; + } + return list; + } + }; + + /** + * Polyfill from . + */ + var _toISOString = function () { + var pad = function pad(n) { + return (n < 10 ? '0' : '') + n; + }; + return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) { + return d.toISOString(); + } : function _toISOString(d) { + return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'; + }; + }(); + + var _xdropRepeatsWith = function () { + function XDropRepeatsWith(pred, xf) { + this.xf = xf; + this.pred = pred; + this.lastValue = undefined; + this.seenFirstValue = false; + } + XDropRepeatsWith.prototype['@@transducer/init'] = function () { + return this.xf['@@transducer/init'](); + }; + XDropRepeatsWith.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](result); + }; + XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) { + var sameAsLast = false; + if (!this.seenFirstValue) { + this.seenFirstValue = true; + } else if (this.pred(this.lastValue, input)) { + sameAsLast = true; + } + this.lastValue = input; + return sameAsLast ? result : this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdropRepeatsWith(pred, xf) { + return new XDropRepeatsWith(pred, xf); + }); + }(); + + var _xfBase = { + init: function () { + return this.xf['@@transducer/init'](); + }, + result: function (result) { + return this.xf['@@transducer/result'](result); + } + }; + + var _xfilter = function () { + function XFilter(f, xf) { + this.xf = xf; + this.f = f; + } + XFilter.prototype['@@transducer/init'] = _xfBase.init; + XFilter.prototype['@@transducer/result'] = _xfBase.result; + XFilter.prototype['@@transducer/step'] = function (result, input) { + return this.f(input) ? this.xf['@@transducer/step'](result, input) : result; + }; + return _curry2(function _xfilter(f, xf) { + return new XFilter(f, xf); + }); + }(); + + var _xfind = function () { + function XFind(f, xf) { + this.xf = xf; + this.f = f; + this.found = false; + } + XFind.prototype['@@transducer/init'] = _xfBase.init; + XFind.prototype['@@transducer/result'] = function (result) { + if (!this.found) { + result = this.xf['@@transducer/step'](result, void 0); + } + return this.xf['@@transducer/result'](result); + }; + XFind.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.found = true; + result = _reduced(this.xf['@@transducer/step'](result, input)); + } + return result; + }; + return _curry2(function _xfind(f, xf) { + return new XFind(f, xf); + }); + }(); + + var _xfindIndex = function () { + function XFindIndex(f, xf) { + this.xf = xf; + this.f = f; + this.idx = -1; + this.found = false; + } + XFindIndex.prototype['@@transducer/init'] = _xfBase.init; + XFindIndex.prototype['@@transducer/result'] = function (result) { + if (!this.found) { + result = this.xf['@@transducer/step'](result, -1); + } + return this.xf['@@transducer/result'](result); + }; + XFindIndex.prototype['@@transducer/step'] = function (result, input) { + this.idx += 1; + if (this.f(input)) { + this.found = true; + result = _reduced(this.xf['@@transducer/step'](result, this.idx)); + } + return result; + }; + return _curry2(function _xfindIndex(f, xf) { + return new XFindIndex(f, xf); + }); + }(); + + var _xfindLast = function () { + function XFindLast(f, xf) { + this.xf = xf; + this.f = f; + } + XFindLast.prototype['@@transducer/init'] = _xfBase.init; + XFindLast.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last)); + }; + XFindLast.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.last = input; + } + return result; + }; + return _curry2(function _xfindLast(f, xf) { + return new XFindLast(f, xf); + }); + }(); + + var _xfindLastIndex = function () { + function XFindLastIndex(f, xf) { + this.xf = xf; + this.f = f; + this.idx = -1; + this.lastIdx = -1; + } + XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init; + XFindLastIndex.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx)); + }; + XFindLastIndex.prototype['@@transducer/step'] = function (result, input) { + this.idx += 1; + if (this.f(input)) { + this.lastIdx = this.idx; + } + return result; + }; + return _curry2(function _xfindLastIndex(f, xf) { + return new XFindLastIndex(f, xf); + }); + }(); + + var _xmap = function () { + function XMap(f, xf) { + this.xf = xf; + this.f = f; + } + XMap.prototype['@@transducer/init'] = _xfBase.init; + XMap.prototype['@@transducer/result'] = _xfBase.result; + XMap.prototype['@@transducer/step'] = function (result, input) { + return this.xf['@@transducer/step'](result, this.f(input)); + }; + return _curry2(function _xmap(f, xf) { + return new XMap(f, xf); + }); + }(); + + var _xtake = function () { + function XTake(n, xf) { + this.xf = xf; + this.n = n; + } + XTake.prototype['@@transducer/init'] = _xfBase.init; + XTake.prototype['@@transducer/result'] = _xfBase.result; + XTake.prototype['@@transducer/step'] = function (result, input) { + if (this.n === 0) { + return _reduced(result); + } else { + this.n -= 1; + return this.xf['@@transducer/step'](result, input); + } + }; + return _curry2(function _xtake(n, xf) { + return new XTake(n, xf); + }); + }(); + + var _xtakeWhile = function () { + function XTakeWhile(f, xf) { + this.xf = xf; + this.f = f; + } + XTakeWhile.prototype['@@transducer/init'] = _xfBase.init; + XTakeWhile.prototype['@@transducer/result'] = _xfBase.result; + XTakeWhile.prototype['@@transducer/step'] = function (result, input) { + return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result); + }; + return _curry2(function _xtakeWhile(f, xf) { + return new XTakeWhile(f, xf); + }); + }(); + + var _xwrap = function () { + function XWrap(fn) { + this.f = fn; + } + XWrap.prototype['@@transducer/init'] = function () { + throw new Error('init not implemented on XWrap'); + }; + XWrap.prototype['@@transducer/result'] = function (acc) { + return acc; + }; + XWrap.prototype['@@transducer/step'] = function (acc, x) { + return this.f(acc, x); + }; + return function _xwrap(fn) { + return new XWrap(fn); + }; + }(); + + /** + * Adds two numbers. Equivalent to `a + b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a + * @param {Number} b + * @return {Number} + * @see R.subtract + * @example + * + * R.add(2, 3); //=> 5 + * R.add(7)(10); //=> 17 + */ + var add = _curry2(function add(a, b) { + return a + b; + }); + + /** + * Applies a function to the value at the given index of an array, + * returning a new copy of the array with the element at the given + * index replaced with the result of the function application. + * @see R.update + * + * @func + * @memberOf R + * @category List + * @sig (a -> a) -> Number -> [a] -> [a] + * @param {Function} fn The function to apply. + * @param {Number} idx The index. + * @param {Array|Arguments} list An array-like object whose value + * at the supplied index will be replaced. + * @return {Array} A copy of the supplied array-like object with + * the element at index `idx` replaced with the value + * returned by applying `fn` to the existing element. + * @example + * + * R.adjust(R.add(10), 1, [0, 1, 2]); //=> [0, 11, 2] + * R.adjust(R.add(10))(1)([0, 1, 2]); //=> [0, 11, 2] + */ + var adjust = _curry3(function adjust(fn, idx, list) { + if (idx >= list.length || idx < -list.length) { + return list; + } + var start = idx < 0 ? list.length : 0; + var _idx = start + idx; + var _list = _concat(list); + _list[_idx] = fn(list[_idx]); + return _list; + }); + + /** + * Returns a function that always returns the given value. Note that for + * non-primitives the value returned is a reference to the original value. + * + * This function is known as `const`, `constant`, or `K` (for K combinator) + * in other languages and libraries. + * + * @func + * @memberOf R + * @category Function + * @sig a -> (* -> a) + * @param {*} val The value to wrap in a function + * @return {Function} A Function :: * -> val. + * @example + * + * var t = R.always('Tee'); + * t(); //=> 'Tee' + */ + var always = _curry1(function always(val) { + return function () { + return val; + }; + }); + + /** + * Returns a new list, composed of n-tuples of consecutive elements + * If `n` is greater than the length of the list, an empty list is returned. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [[a]] + * @param {Number} n The size of the tuples to create + * @param {Array} list The list to split into `n`-tuples + * @return {Array} The new list. + * @example + * + * R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]] + * R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]] + * R.aperture(7, [1, 2, 3, 4, 5]); //=> [] + */ + var aperture = _curry2(function aperture(n, list) { + var idx = 0; + var limit = list.length - (n - 1); + var acc = new Array(limit >= 0 ? limit : 0); + while (idx < limit) { + acc[idx] = _slice(list, idx, idx + n); + idx += 1; + } + return acc; + }); + + /** + * Returns a new list containing the contents of the given list, followed by the given + * element. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The element to add to the end of the new list. + * @param {Array} list The list whose contents will be added to the beginning of the output + * list. + * @return {Array} A new list containing the contents of the old list followed by `el`. + * @see R.prepend + * @example + * + * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests'] + * R.append('tests', []); //=> ['tests'] + * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] + */ + var append = _curry2(function append(el, list) { + return _concat(list, [el]); + }); + + /** + * Applies function `fn` to the argument list `args`. This is useful for + * creating a fixed-arity function from a variadic function. `fn` should + * be a bound function if context is significant. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a) -> [*] -> a + * @param {Function} fn + * @param {Array} args + * @return {*} + * @see R.call, R.unapply + * @example + * + * var nums = [1, 2, 3, -99, 42, 6, 7]; + * R.apply(Math.max, nums); //=> 42 + */ + var apply = _curry2(function apply(fn, args) { + return fn.apply(this, args); + }); + + /** + * Makes a shallow clone of an object, setting or overriding the specified + * property with the given value. Note that this copies and flattens + * prototype properties onto the new object as well. All non-primitive + * properties are copied by reference. + * + * @func + * @memberOf R + * @category Object + * @sig String -> a -> {k: v} -> {k: v} + * @param {String} prop the property name to set + * @param {*} val the new value + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original except for the specified property. + * @see R.dissoc + * @example + * + * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3} + */ + var assoc = _curry3(function assoc(prop, val, obj) { + var result = {}; + for (var p in obj) { + result[p] = obj[p]; + } + result[prop] = val; + return result; + }); + + /** + * Makes a shallow clone of an object, setting or overriding the nodes + * required to create the given path, and placing the specific value at the + * tail end of that path. Note that this copies and flattens prototype + * properties onto the new object as well. All non-primitive properties + * are copied by reference. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> a -> {k: v} -> {k: v} + * @param {Array} path the path to set + * @param {*} val the new value + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original except along the specified path. + * @see R.dissocPath + * @example + * + * R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}} + */ + var assocPath = _curry3(function assocPath(path, val, obj) { + switch (path.length) { + case 0: + return obj; + case 1: + return assoc(path[0], val, obj); + default: + return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj); + } + }); + + /** + * Creates a function that is bound to a context. + * Note: `R.bind` does not provide the additional argument-binding capabilities of + * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind). + * + * @func + * @memberOf R + * @category Function + * @category Object + * @see R.partial + * @sig (* -> *) -> {*} -> (* -> *) + * @param {Function} fn The function to bind to context + * @param {Object} thisObj The context to bind `fn` to + * @return {Function} A function that will execute in the context of `thisObj`. + */ + var bind = _curry2(function bind(fn, thisObj) { + return _arity(fn.length, function () { + return fn.apply(thisObj, arguments); + }); + }); + + /** + * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first + * function if it is false-y and the result of the second function otherwise. Note that this is + * short-circuited, meaning that the second function will not be invoked if the first returns a false-y + * value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) + * @param {Function} f a predicate + * @param {Function} g another predicate + * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together. + * @see R.and + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0 }; + * var f = R.both(gt10, even); + * f(100); //=> true + * f(101); //=> false + */ + var both = _curry2(function both(f, g) { + return function _both() { + return f.apply(this, arguments) && g.apply(this, arguments); + }; + }); + + /** + * Makes a comparator function out of a function that reports whether the first element is less than the second. + * + * @func + * @memberOf R + * @category Function + * @sig (a, b -> Boolean) -> (a, b -> Number) + * @param {Function} pred A predicate function of arity two. + * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`. + * @example + * + * var cmp = R.comparator(function(a, b) { + * return a.age < b.age; + * }); + * var people = [ + * // ... + * ]; + * R.sort(cmp, people); + */ + var comparator = _curry1(function comparator(pred) { + return function (a, b) { + return pred(a, b) ? -1 : pred(b, a) ? 1 : 0; + }; + }); + + /** + * Takes a function `f` and returns a function `g` such that: + * + * - applying `g` to zero or more arguments will give __true__ if applying + * the same arguments to `f` gives a logical __false__ value; and + * + * - applying `g` to zero or more arguments will give __false__ if applying + * the same arguments to `f` gives a logical __true__ value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> *) -> (*... -> Boolean) + * @param {Function} f + * @return {Function} + * @see R.not + * @example + * + * var isEven = function(n) { return n % 2 === 0; }; + * var isOdd = R.complement(isEven); + * isOdd(21); //=> true + * isOdd(42); //=> false + */ + var complement = _curry1(_complement); + + /** + * Returns a function, `fn`, which encapsulates if/else-if/else logic. + * `R.cond` takes a list of [predicate, transform] pairs. All of the + * arguments to `fn` are applied to each of the predicates in turn + * until one returns a "truthy" value, at which point `fn` returns the + * result of applying its arguments to the corresponding transformer. + * If none of the predicates matches, `fn` returns undefined. + * + * @func + * @memberOf R + * @category Logic + * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *) + * @param {Array} pairs + * @return {Function} + * @example + * + * var fn = R.cond([ + * [R.equals(0), R.always('water freezes at 0°C')], + * [R.equals(100), R.always('water boils at 100°C')], + * [R.T, function(temp) { return 'nothing special happens at ' + temp + '°C'; }] + * ]); + * fn(0); //=> 'water freezes at 0°C' + * fn(50); //=> 'nothing special happens at 50°C' + * fn(100); //=> 'water boils at 100°C' + */ + var cond = _curry1(function cond(pairs) { + return function () { + var idx = 0; + while (idx < pairs.length) { + if (pairs[idx][0].apply(this, arguments)) { + return pairs[idx][1].apply(this, arguments); + } + idx += 1; + } + }; + }); + + /** + * Returns `true` if the `x` is found in the `list`, using `pred` as an + * equality predicate for `x`. + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> a -> [a] -> Boolean + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {*} x The item to find + * @param {Array} list The list to iterate over + * @return {Boolean} `true` if `x` is in `list`, else `false`. + * @example + * + * var xs = [{x: 12}, {x: 11}, {x: 10}]; + * R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true + * R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false + */ + var containsWith = _curry3(_containsWith); + + /** + * Counts the elements of a list according to how many match each value + * of a key generated by the supplied function. Returns an object + * mapping the keys produced by `fn` to the number of occurrences in + * the list. Note that all keys are coerced to strings because of how + * JavaScript objects work. + * + * @func + * @memberOf R + * @category Relation + * @sig (a -> String) -> [a] -> {*} + * @param {Function} fn The function used to map values to keys. + * @param {Array} list The list to count elements from. + * @return {Object} An object mapping keys to number of occurrences in the list. + * @example + * + * var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2]; + * var letters = R.split('', 'abcABCaaaBBc'); + * R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1} + * R.countBy(R.toLower)(letters); //=> {'a': 5, 'b': 4, 'c': 3} + */ + var countBy = _curry2(function countBy(fn, list) { + var counts = {}; + var len = list.length; + var idx = 0; + while (idx < len) { + var key = fn(list[idx]); + counts[key] = (_has(key, counts) ? counts[key] : 0) + 1; + idx += 1; + } + return counts; + }); + + /** + * Creates an object containing a single key:value pair. + * + * @func + * @memberOf R + * @category Object + * @sig String -> a -> {String:a} + * @param {String} key + * @param {*} val + * @return {Object} + * @example + * + * var matchPhrases = R.compose( + * R.createMapEntry('must'), + * R.map(R.createMapEntry('match_phrase')) + * ); + * matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]} + */ + var createMapEntry = _curry2(function createMapEntry(key, val) { + var obj = {}; + obj[key] = val; + return obj; + }); + + /** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ + var curryN = _curry2(function curryN(length, fn) { + if (length === 1) { + return _curry1(fn); + } + return _arity(length, _curryN(length, [], fn)); + }); + + /** + * Decrements its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @see R.inc + * @example + * + * R.dec(42); //=> 41 + */ + var dec = add(-1); + + /** + * Returns the second argument if it is not null or undefined. If it is null + * or undefined, the first (default) argument is returned. + * + * @func + * @memberOf R + * @category Logic + * @sig a -> b -> a | b + * @param {a} val The default value. + * @param {b} val The value to return if it is not null or undefined + * @return {*} The the second value or the default value + * @example + * + * var defaultTo42 = defaultTo(42); + * + * defaultTo42(null); //=> 42 + * defaultTo42(undefined); //=> 42 + * defaultTo42('Ramda'); //=> 'Ramda' + */ + var defaultTo = _curry2(function defaultTo(d, v) { + return v == null ? d : v; + }); + + /** + * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. + * Duplication is determined according to the value returned by applying the supplied predicate to two list + * elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @see R.difference + * @return {Array} The elements in `list1` that are not in `list2`. + * @example + * + * function cmp(x, y) { return x.a === y.a; } + * var l1 = [{a: 1}, {a: 2}, {a: 3}]; + * var l2 = [{a: 3}, {a: 4}]; + * R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}] + */ + var differenceWith = _curry3(function differenceWith(pred, first, second) { + var out = []; + var idx = 0; + var firstLen = first.length; + var containsPred = containsWith(pred); + while (idx < firstLen) { + if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) { + out[out.length] = first[idx]; + } + idx += 1; + } + return out; + }); + + /** + * Returns a new object that does not contain a `prop` property. + * + * @func + * @memberOf R + * @category Object + * @sig String -> {k: v} -> {k: v} + * @param {String} prop the name of the property to dissociate + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original but without the specified property + * @see R.assoc + * @example + * + * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} + */ + var dissoc = _curry2(function dissoc(prop, obj) { + var result = {}; + for (var p in obj) { + if (p !== prop) { + result[p] = obj[p]; + } + } + return result; + }); + + /** + * Makes a shallow clone of an object, omitting the property at the + * given path. Note that this copies and flattens prototype properties + * onto the new object as well. All non-primitive properties are copied + * by reference. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {k: v} -> {k: v} + * @param {Array} path the path to set + * @param {Object} obj the object to clone + * @return {Object} a new object without the property at path + * @see R.assocPath + * @example + * + * R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}} + */ + var dissocPath = _curry2(function dissocPath(path, obj) { + switch (path.length) { + case 0: + return obj; + case 1: + return dissoc(path[0], obj); + default: + var head = path[0]; + var tail = _slice(path, 1); + return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj); + } + }); + + /** + * Divides two numbers. Equivalent to `a / b`. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a / b`. + * @see R.multiply + * @example + * + * R.divide(71, 100); //=> 0.71 + * + * var half = R.divide(R.__, 2); + * half(42); //=> 21 + * + * var reciprocal = R.divide(1); + * reciprocal(4); //=> 0.25 + */ + var divide = _curry2(function divide(a, b) { + return a / b; + }); + + /** + * Returns a new list containing all but last the`n` elements of a given list, + * passing each value from the right to the supplied predicate function, skipping + * elements while the predicate function returns `true`. The predicate function + * is passed one argument: (value)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.takeLastWhile + * @example + * + * var lteThree = function(x) { + * return x <= 3; + * }; + * + * R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2] + */ + var dropLastWhile = _curry2(function dropLastWhile(pred, list) { + var idx = list.length - 1; + while (idx >= 0 && pred(list[idx])) { + idx -= 1; + } + return _slice(list, 0, idx + 1); + }); + + /** + * A function wrapping calls to the two functions in an `||` operation, returning the result of the first + * function if it is truth-y and the result of the second function otherwise. Note that this is + * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y + * value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) + * @param {Function} f a predicate + * @param {Function} g another predicate + * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together. + * @see R.or + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0 }; + * var f = R.either(gt10, even); + * f(101); //=> true + * f(8); //=> true + */ + var either = _curry2(function either(f, g) { + return function _either() { + return f.apply(this, arguments) || g.apply(this, arguments); + }; + }); + + /** + * Returns the empty value of its argument's type. Ramda defines the empty + * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are + * supported if they define `.empty` and/or `.prototype.empty`. + * + * @func + * @memberOf R + * @category Function + * @sig a -> a + * @param {*} x + * @return {*} + * @example + * + * R.empty(Just(42)); //=> Nothing() + * R.empty([1, 2, 3]); //=> [] + * R.empty('unicorns'); //=> '' + * R.empty({x: 1, y: 2}); //=> {} + */ + var empty = _curry1(function empty(x) { + if (x != null && typeof x.empty === 'function') { + return x.empty(); + } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') { + return x.constructor.empty(); + } else { + switch (Object.prototype.toString.call(x)) { + case '[object Array]': + return []; + case '[object Object]': + return {}; + case '[object String]': + return ''; + } + } + }); + + /** + * Creates a new object by recursively evolving a shallow copy of `object`, according to the + * `transformation` functions. All non-primitive properties are copied by reference. + * + * A `tranformation` function will not be invoked if its corresponding key does not exist in + * the evolved object. + * + * @func + * @memberOf R + * @category Object + * @sig {k: (v -> v)} -> {k: v} -> {k: v} + * @param {Object} transformations The object specifying transformation functions to apply + * to the object. + * @param {Object} object The object to be transformed. + * @return {Object} The transformed object. + * @example + * + * var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123}; + * var transformations = { + * firstName: R.trim, + * lastName: R.trim, // Will not get invoked. + * data: {elapsed: R.add(1), remaining: R.add(-1)} + * }; + * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} + */ + var evolve = _curry2(function evolve(transformations, object) { + var transformation, key, type, result = {}; + for (key in object) { + transformation = transformations[key]; + type = typeof transformation; + result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key]; + } + return result; + }); + + /** + * Creates a new object out of a list key-value pairs. + * + * @func + * @memberOf R + * @category List + * @sig [[k,v]] -> {k: v} + * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object. + * @return {Object} The object made by pairing up `keys` and `values`. + * @see R.toPairs + * @example + * + * R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3} + */ + var fromPairs = _curry1(function fromPairs(pairs) { + var idx = 0, len = pairs.length, out = {}; + while (idx < len) { + if (_isArray(pairs[idx]) && pairs[idx].length) { + out[pairs[idx][0]] = pairs[idx][1]; + } + idx += 1; + } + return out; + }); + + /** + * Returns `true` if the first argument is greater than the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @see R.lt + * @example + * + * R.gt(2, 1); //=> true + * R.gt(2, 2); //=> false + * R.gt(2, 3); //=> false + * R.gt('a', 'z'); //=> false + * R.gt('z', 'a'); //=> true + */ + var gt = _curry2(function gt(a, b) { + return a > b; + }); + + /** + * Returns `true` if the first argument is greater than or equal to the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {Number} a + * @param {Number} b + * @return {Boolean} + * @see R.lte + * @example + * + * R.gte(2, 1); //=> true + * R.gte(2, 2); //=> true + * R.gte(2, 3); //=> false + * R.gte('a', 'z'); //=> false + * R.gte('z', 'a'); //=> true + */ + var gte = _curry2(function gte(a, b) { + return a >= b; + }); + + /** + * Returns whether or not an object has an own property with + * the specified name + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: x} -> Boolean + * @param {String} prop The name of the property to check for. + * @param {Object} obj The object to query. + * @return {Boolean} Whether the property exists. + * @example + * + * var hasName = R.has('name'); + * hasName({name: 'alice'}); //=> true + * hasName({name: 'bob'}); //=> true + * hasName({}); //=> false + * + * var point = {x: 0, y: 0}; + * var pointHas = R.has(R.__, point); + * pointHas('x'); //=> true + * pointHas('y'); //=> true + * pointHas('z'); //=> false + */ + var has = _curry2(_has); + + /** + * Returns whether or not an object or its prototype chain has + * a property with the specified name + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: x} -> Boolean + * @param {String} prop The name of the property to check for. + * @param {Object} obj The object to query. + * @return {Boolean} Whether the property exists. + * @example + * + * function Rectangle(width, height) { + * this.width = width; + * this.height = height; + * } + * Rectangle.prototype.area = function() { + * return this.width * this.height; + * }; + * + * var square = new Rectangle(2, 2); + * R.hasIn('width', square); //=> true + * R.hasIn('area', square); //=> true + */ + var hasIn = _curry2(function hasIn(prop, obj) { + return prop in obj; + }); + + /** + * Returns true if its arguments are identical, false otherwise. Values are + * identical if they reference the same memory. `NaN` is identical to `NaN`; + * `0` and `-0` are not identical. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * var o = {}; + * R.identical(o, o); //=> true + * R.identical(1, 1); //=> true + * R.identical(1, '1'); //=> false + * R.identical([], []); //=> false + * R.identical(0, -0); //=> false + * R.identical(NaN, NaN); //=> true + */ + // SameValue algorithm + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + // Step 6.a: NaN == NaN + var identical = _curry2(function identical(a, b) { + // SameValue algorithm + if (a === b) { + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + return a !== 0 || 1 / a === 1 / b; + } else { + // Step 6.a: NaN == NaN + return a !== a && b !== b; + } + }); + + /** + * A function that does nothing but return the parameter supplied to it. Good as a default + * or placeholder function. + * + * @func + * @memberOf R + * @category Function + * @sig a -> a + * @param {*} x The value to return. + * @return {*} The input value, `x`. + * @example + * + * R.identity(1); //=> 1 + * + * var obj = {}; + * R.identity(obj) === obj; //=> true + */ + var identity = _curry1(_identity); + + /** + * Creates a function that will process either the `onTrue` or the `onFalse` function depending + * upon the result of the `condition` predicate. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *) + * @param {Function} condition A predicate function + * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value. + * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value. + * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse` + * function depending upon the result of the `condition` predicate. + * @example + * + * // Flatten all arrays in the list but leave other values alone. + * var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity)); + * + * flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}] + * flattenArrays([[[10], 123], [8, [10]], "hello"]); //=> [[10, 123], [8, 10], "hello"] + */ + var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) { + return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() { + return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments); + }); + }); + + /** + * Increments its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @see R.dec + * @example + * + * R.inc(42); //=> 43 + */ + var inc = add(1); + + /** + * Inserts the supplied element into the list, at index `index`. _Note + * that this is not destructive_: it returns a copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> a -> [a] -> [a] + * @param {Number} index The position to insert the element + * @param {*} elt The element to insert into the Array + * @param {Array} list The list to insert into + * @return {Array} A new Array with `elt` inserted at `index`. + * @example + * + * R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4] + */ + var insert = _curry3(function insert(idx, elt, list) { + idx = idx < list.length && idx >= 0 ? idx : list.length; + var result = _slice(list); + result.splice(idx, 0, elt); + return result; + }); + + /** + * Inserts the sub-list into the list, at index `index`. _Note that this + * is not destructive_: it returns a copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] -> [a] + * @param {Number} index The position to insert the sub-list + * @param {Array} elts The sub-list to insert into the Array + * @param {Array} list The list to insert the sub-list into + * @return {Array} A new Array with `elts` inserted starting at `index`. + * @example + * + * R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4] + */ + var insertAll = _curry3(function insertAll(idx, elts, list) { + idx = idx < list.length && idx >= 0 ? idx : list.length; + return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx)); + }); + + /** + * See if an object (`val`) is an instance of the supplied constructor. + * This function will check up the inheritance chain, if any. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> a -> Boolean + * @param {Object} ctor A constructor + * @param {*} val The value to test + * @return {Boolean} + * @example + * + * R.is(Object, {}); //=> true + * R.is(Number, 1); //=> true + * R.is(Object, 1); //=> false + * R.is(String, 's'); //=> true + * R.is(String, new String('')); //=> true + * R.is(Object, new String('')); //=> true + * R.is(Object, 's'); //=> false + * R.is(Number, {}); //=> false + */ + var is = _curry2(function is(Ctor, val) { + return val != null && val.constructor === Ctor || val instanceof Ctor; + }); + + /** + * Tests whether or not an object is similar to an array. + * + * @func + * @memberOf R + * @category Type + * @category List + * @sig * -> Boolean + * @param {*} x The object to test. + * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise. + * @example + * + * R.isArrayLike([]); //=> true + * R.isArrayLike(true); //=> false + * R.isArrayLike({}); //=> false + * R.isArrayLike({length: 10}); //=> false + * R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true + */ + var isArrayLike = _curry1(function isArrayLike(x) { + if (_isArray(x)) { + return true; + } + if (!x) { + return false; + } + if (typeof x !== 'object') { + return false; + } + if (x instanceof String) { + return false; + } + if (x.nodeType === 1) { + return !!x.length; + } + if (x.length === 0) { + return true; + } + if (x.length > 0) { + return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1); + } + return false; + }); + + /** + * Reports whether the list has zero elements. + * + * @func + * @memberOf R + * @category Logic + * @sig [a] -> Boolean + * @param {Array} list + * @return {Boolean} + * @example + * + * R.isEmpty([1, 2, 3]); //=> false + * R.isEmpty([]); //=> true + * R.isEmpty(''); //=> true + * R.isEmpty(null); //=> false + * R.isEmpty(R.keys({})); //=> true + * R.isEmpty({}); //=> false ({} does not have a length property) + * R.isEmpty({length: 0}); //=> true + */ + var isEmpty = _curry1(function isEmpty(list) { + return Object(list).length === 0; + }); + + /** + * Checks if the input value is `null` or `undefined`. + * + * @func + * @memberOf R + * @category Type + * @sig * -> Boolean + * @param {*} x The value to test. + * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`. + * @example + * + * R.isNil(null); //=> true + * R.isNil(undefined); //=> true + * R.isNil(0); //=> false + * R.isNil([]); //=> false + */ + var isNil = _curry1(function isNil(x) { + return x == null; + }); + + /** + * Returns a list containing the names of all the enumerable own + * properties of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own properties. + * @example + * + * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] + */ + // cover IE < 9 keys issues + var keys = function () { + // cover IE < 9 keys issues + var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString'); + var nonEnumerableProps = [ + 'constructor', + 'valueOf', + 'isPrototypeOf', + 'toString', + 'propertyIsEnumerable', + 'hasOwnProperty', + 'toLocaleString' + ]; + var contains = function contains(list, item) { + var idx = 0; + while (idx < list.length) { + if (list[idx] === item) { + return true; + } + idx += 1; + } + return false; + }; + return typeof Object.keys === 'function' ? _curry1(function keys(obj) { + return Object(obj) !== obj ? [] : Object.keys(obj); + }) : _curry1(function keys(obj) { + if (Object(obj) !== obj) { + return []; + } + var prop, ks = [], nIdx; + for (prop in obj) { + if (_has(prop, obj)) { + ks[ks.length] = prop; + } + } + if (hasEnumBug) { + nIdx = nonEnumerableProps.length - 1; + while (nIdx >= 0) { + prop = nonEnumerableProps[nIdx]; + if (_has(prop, obj) && !contains(ks, prop)) { + ks[ks.length] = prop; + } + nIdx -= 1; + } + } + return ks; + }); + }(); + + /** + * Returns a list containing the names of all the + * properties of the supplied object, including prototype properties. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.keysIn(f); //=> ['x', 'y'] + */ + var keysIn = _curry1(function keysIn(obj) { + var prop, ks = []; + for (prop in obj) { + ks[ks.length] = prop; + } + return ks; + }); + + /** + * Returns the number of elements in the array by returning `list.length`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> Number + * @param {Array} list The array to inspect. + * @return {Number} The length of the array. + * @example + * + * R.length([]); //=> 0 + * R.length([1, 2, 3]); //=> 3 + */ + var length = _curry1(function length(list) { + return list != null && is(Number, list.length) ? list.length : NaN; + }); + + /** + * Returns `true` if the first argument is less than the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @see R.gt + * @example + * + * R.lt(2, 1); //=> false + * R.lt(2, 2); //=> false + * R.lt(2, 3); //=> true + * R.lt('a', 'z'); //=> true + * R.lt('z', 'a'); //=> false + */ + var lt = _curry2(function lt(a, b) { + return a < b; + }); + + /** + * Returns `true` if the first argument is less than or equal to the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {Number} a + * @param {Number} b + * @return {Boolean} + * @see R.gte + * @example + * + * R.lte(2, 1); //=> false + * R.lte(2, 2); //=> true + * R.lte(2, 3); //=> true + * R.lte('a', 'z'); //=> true + * R.lte('z', 'a'); //=> false + */ + var lte = _curry2(function lte(a, b) { + return a <= b; + }); + + /** + * The mapAccum function behaves like a combination of map and reduce; it applies a + * function to each element of a list, passing an accumulating parameter from left to + * right, and returning a final value of this accumulator together with the new list. + * + * The iterator function receives two arguments, *acc* and *value*, and should return + * a tuple *[acc, value]*. + * + * @func + * @memberOf R + * @category List + * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var digits = ['1', '2', '3', '4']; + * var append = function(a, b) { + * return [a + b, a + b]; + * } + * + * R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']] + */ + var mapAccum = _curry3(function mapAccum(fn, acc, list) { + var idx = 0, len = list.length, result = [], tuple = [acc]; + while (idx < len) { + tuple = fn(tuple[0], list[idx]); + result[idx] = tuple[1]; + idx += 1; + } + return [ + tuple[0], + result + ]; + }); + + /** + * The mapAccumRight function behaves like a combination of map and reduce; it applies a + * function to each element of a list, passing an accumulating parameter from right + * to left, and returning a final value of this accumulator together with the new list. + * + * Similar to `mapAccum`, except moves through the input list from the right to the + * left. + * + * The iterator function receives two arguments, *acc* and *value*, and should return + * a tuple *[acc, value]*. + * + * @func + * @memberOf R + * @category List + * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var digits = ['1', '2', '3', '4']; + * var append = function(a, b) { + * return [a + b, a + b]; + * } + * + * R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']] + */ + var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) { + var idx = list.length - 1, result = [], tuple = [acc]; + while (idx >= 0) { + tuple = fn(tuple[0], list[idx]); + result[idx] = tuple[1]; + idx -= 1; + } + return [ + tuple[0], + result + ]; + }); + + /** + * Tests a regular expression against a String. Note that this function + * will return an empty array when there are no matches. This differs + * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) + * which returns `null` when there are no matches. + * + * @func + * @memberOf R + * @see R.test + * @category String + * @sig RegExp -> String -> [String | Undefined] + * @param {RegExp} rx A regular expression. + * @param {String} str The string to match against + * @return {Array} The list of matches or empty array. + * @example + * + * R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na'] + * R.match(/a/, 'b'); //=> [] + * R.match(/a/, null); //=> TypeError: null does not have a method named "match" + */ + var match = _curry2(function match(rx, str) { + return str.match(rx) || []; + }); + + /** + * mathMod behaves like the modulo operator should mathematically, unlike the `%` + * operator (and by extension, R.modulo). So while "-17 % 5" is -2, + * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN + * when the modulus is zero or negative. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} m The dividend. + * @param {Number} p the modulus. + * @return {Number} The result of `b mod a`. + * @example + * + * R.mathMod(-17, 5); //=> 3 + * R.mathMod(17, 5); //=> 2 + * R.mathMod(17, -5); //=> NaN + * R.mathMod(17, 0); //=> NaN + * R.mathMod(17.2, 5); //=> NaN + * R.mathMod(17, 5.3); //=> NaN + * + * var clock = R.mathMod(R.__, 12); + * clock(15); //=> 3 + * clock(24); //=> 0 + * + * var seventeenMod = R.mathMod(17); + * seventeenMod(3); //=> 2 + * seventeenMod(4); //=> 1 + * seventeenMod(10); //=> 7 + */ + var mathMod = _curry2(function mathMod(m, p) { + if (!_isInteger(m)) { + return NaN; + } + if (!_isInteger(p) || p < 1) { + return NaN; + } + return (m % p + p) % p; + }); + + /** + * Returns the larger of its two arguments. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> a + * @param {*} a + * @param {*} b + * @return {*} + * @see R.maxBy, R.min + * @example + * + * R.max(789, 123); //=> 789 + * R.max('a', 'b'); //=> 'b' + */ + var max = _curry2(function max(a, b) { + return b > a ? b : a; + }); + + /** + * Takes a function and two values, and returns whichever value produces + * the larger result when passed to the provided function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> a -> a -> a + * @param {Function} f + * @param {*} a + * @param {*} b + * @return {*} + * @see R.max, R.minBy + * @example + * + * R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3 + */ + var maxBy = _curry3(function maxBy(f, a, b) { + return f(b) > f(a) ? b : a; + }); + + /** + * Create a new object with the own properties of `a` + * merged with the own properties of object `b`. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> {k: v} -> {k: v} + * @param {Object} a + * @param {Object} b + * @return {Object} + * @example + * + * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); + * //=> { 'name': 'fred', 'age': 40 } + * + * var resetToDefault = R.merge(R.__, {x: 0}); + * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} + */ + var merge = _curry2(function merge(a, b) { + var result = {}; + var ks = keys(a); + var idx = 0; + while (idx < ks.length) { + result[ks[idx]] = a[ks[idx]]; + idx += 1; + } + ks = keys(b); + idx = 0; + while (idx < ks.length) { + result[ks[idx]] = b[ks[idx]]; + idx += 1; + } + return result; + }); + + /** + * Returns the smaller of its two arguments. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> a + * @param {*} a + * @param {*} b + * @return {*} + * @see R.minBy, R.max + * @example + * + * R.min(789, 123); //=> 123 + * R.min('a', 'b'); //=> 'a' + */ + var min = _curry2(function min(a, b) { + return b < a ? b : a; + }); + + /** + * Takes a function and two values, and returns whichever value produces + * the smaller result when passed to the provided function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> a -> a -> a + * @param {Function} f + * @param {*} a + * @param {*} b + * @return {*} + * @see R.min, R.maxBy + * @example + * + * R.minBy(function(n) { return n * n; }, -3, 2); //=> 2 + */ + var minBy = _curry3(function minBy(f, a, b) { + return f(b) < f(a) ? b : a; + }); + + /** + * Divides the second parameter by the first and returns the remainder. + * Note that this functions preserves the JavaScript-style behavior for + * modulo. For mathematical modulo see `mathMod` + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The value to the divide. + * @param {Number} b The pseudo-modulus + * @return {Number} The result of `b % a`. + * @see R.mathMod + * @example + * + * R.modulo(17, 3); //=> 2 + * // JS behavior: + * R.modulo(-17, 3); //=> -2 + * R.modulo(17, -3); //=> 2 + * + * var isOdd = R.modulo(R.__, 2); + * isOdd(42); //=> 0 + * isOdd(21); //=> 1 + */ + var modulo = _curry2(function modulo(a, b) { + return a % b; + }); + + /** + * Multiplies two numbers. Equivalent to `a * b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a * b`. + * @see R.divide + * @example + * + * var double = R.multiply(2); + * var triple = R.multiply(3); + * double(3); //=> 6 + * triple(4); //=> 12 + * R.multiply(2, 5); //=> 10 + */ + var multiply = _curry2(function multiply(a, b) { + return a * b; + }); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly `n` + * parameters. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} n The desired arity of the new function. + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity `n`. + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.nAry(1, takesTwoArgs); + * takesOneArg.length; //=> 1 + * // Only `n` arguments are passed to the wrapped function + * takesOneArg(1, 2); //=> [1, undefined] + */ + var nAry = _curry2(function nAry(n, fn) { + switch (n) { + case 0: + return function () { + return fn.call(this); + }; + case 1: + return function (a0) { + return fn.call(this, a0); + }; + case 2: + return function (a0, a1) { + return fn.call(this, a0, a1); + }; + case 3: + return function (a0, a1, a2) { + return fn.call(this, a0, a1, a2); + }; + case 4: + return function (a0, a1, a2, a3) { + return fn.call(this, a0, a1, a2, a3); + }; + case 5: + return function (a0, a1, a2, a3, a4) { + return fn.call(this, a0, a1, a2, a3, a4); + }; + case 6: + return function (a0, a1, a2, a3, a4, a5) { + return fn.call(this, a0, a1, a2, a3, a4, a5); + }; + case 7: + return function (a0, a1, a2, a3, a4, a5, a6) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6); + }; + case 8: + return function (a0, a1, a2, a3, a4, a5, a6, a7) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7); + }; + case 9: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8); + }; + case 10: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + }; + default: + throw new Error('First argument to nAry must be a non-negative integer no greater than ten'); + } + }); + + /** + * Negates its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @example + * + * R.negate(42); //=> -42 + */ + var negate = _curry1(function negate(n) { + return -n; + }); + + /** + * A function that returns the `!` of its argument. It will return `true` when + * passed false-y value, and `false` when passed a truth-y one. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> Boolean + * @param {*} a any value + * @return {Boolean} the logical inverse of passed argument. + * @see R.complement + * @example + * + * R.not(true); //=> false + * R.not(false); //=> true + * R.not(0); => true + * R.not(1); => false + */ + var not = _curry1(function not(a) { + return !a; + }); + + /** + * Returns the nth element of the given list or string. + * If n is negative the element at index length + n is returned. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> a | Undefined + * @sig Number -> String -> String + * @param {Number} offset + * @param {*} list + * @return {*} + * @example + * + * var list = ['foo', 'bar', 'baz', 'quux']; + * R.nth(1, list); //=> 'bar' + * R.nth(-1, list); //=> 'quux' + * R.nth(-99, list); //=> undefined + * + * R.nth('abc', 2); //=> 'c' + * R.nth('abc', 3); //=> '' + */ + var nth = _curry2(function nth(offset, list) { + var idx = offset < 0 ? list.length + offset : offset; + return _isString(list) ? list.charAt(idx) : list[idx]; + }); + + /** + * Returns a function which returns its nth argument. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> *... -> * + * @param {Number} n + * @return {Function} + * @example + * + * R.nthArg(1)('a', 'b', 'c'); //=> 'b' + * R.nthArg(-1)('a', 'b', 'c'); //=> 'c' + */ + var nthArg = _curry1(function nthArg(n) { + return function () { + return nth(n, arguments); + }; + }); + + /** + * Returns the nth character of the given string. + * + * @func + * @memberOf R + * @category String + * @sig Number -> String -> String + * @param {Number} n + * @param {String} str + * @return {String} + * @deprecated since v0.16.0 + * @example + * + * R.nthChar(2, 'Ramda'); //=> 'm' + * R.nthChar(-2, 'Ramda'); //=> 'd' + */ + var nthChar = _curry2(function nthChar(n, str) { + return str.charAt(n < 0 ? str.length + n : n); + }); + + /** + * Returns the character code of the nth character of the given string. + * + * @func + * @memberOf R + * @category String + * @sig Number -> String -> Number + * @param {Number} n + * @param {String} str + * @return {Number} + * @deprecated since v0.16.0 + * @example + * + * R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0) + * R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0) + */ + var nthCharCode = _curry2(function nthCharCode(n, str) { + return str.charCodeAt(n < 0 ? str.length + n : n); + }); + + /** + * Returns a singleton array containing the value provided. + * + * Note this `of` is different from the ES6 `of`; See + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of + * + * @func + * @memberOf R + * @category Function + * @sig a -> [a] + * @param {*} x any value + * @return {Array} An array wrapping `x`. + * @example + * + * R.of(null); //=> [null] + * R.of([42]); //=> [[42]] + */ + var of = _curry1(function of(x) { + return [x]; + }); + + /** + * Accepts a function `fn` and returns a function that guards invocation of `fn` such that + * `fn` can only ever be called once, no matter how many times the returned function is + * invoked. + * + * @func + * @memberOf R + * @category Function + * @sig (a... -> b) -> (a... -> b) + * @param {Function} fn The function to wrap in a call-only-once wrapper. + * @return {Function} The wrapped function. + * @example + * + * var addOneOnce = R.once(function(x){ return x + 1; }); + * addOneOnce(10); //=> 11 + * addOneOnce(addOneOnce(50)); //=> 11 + */ + var once = _curry1(function once(fn) { + var called = false, result; + return function () { + if (called) { + return result; + } + called = true; + result = fn.apply(this, arguments); + return result; + }; + }); + + /** + * Returns the result of "setting" the portion of the given data structure + * focused by the given lens to the given value. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> (a -> a) -> s -> s + * @param {Lens} lens + * @param {*} v + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var headLens = R.lensIndex(0); + * + * R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz'] + */ + var over = function () { + var Identity = function (x) { + return { + value: x, + map: function (f) { + return Identity(f(x)); + } + }; + }; + return _curry3(function over(lens, f, x) { + return lens(function (y) { + return Identity(f(y)); + })(x).value; + }); + }(); + + /** + * Retrieve the value at a given path. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {k: v} -> v | Undefined + * @param {Array} path The path to use. + * @return {*} The data at `path`. + * @example + * + * R.path(['a', 'b'], {a: {b: 2}}); //=> 2 + * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined + */ + var path = _curry2(function path(paths, obj) { + if (obj == null) { + return; + } else { + var val = obj; + for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) { + val = val[paths[idx]]; + } + return val; + } + }); + + /** + * Returns a partial copy of an object containing only the keys specified. If the key does not exist, the + * property is ignored. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> {k: v} + * @param {Array} names an array of String property names to copy onto a new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties from `names` on it. + * @see R.omit + * @example + * + * R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} + * R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1} + */ + var pick = _curry2(function pick(names, obj) { + var result = {}; + var idx = 0; + while (idx < names.length) { + if (names[idx] in obj) { + result[names[idx]] = obj[names[idx]]; + } + idx += 1; + } + return result; + }); + + /** + * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> {k: v} + * @param {Array} names an array of String property names to copy onto a new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties from `names` on it. + * @see R.pick + * @example + * + * R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} + * R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined} + */ + var pickAll = _curry2(function pickAll(names, obj) { + var result = {}; + var idx = 0; + var len = names.length; + while (idx < len) { + var name = names[idx]; + result[name] = obj[name]; + idx += 1; + } + return result; + }); + + /** + * Returns a partial copy of an object containing only the keys that + * satisfy the supplied predicate. + * + * @func + * @memberOf R + * @category Object + * @sig (v, k -> Boolean) -> {k: v} -> {k: v} + * @param {Function} pred A predicate to determine whether or not a key + * should be included on the output object. + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties that satisfy `pred` + * on it. + * @see R.pick + * @example + * + * var isUpperCase = function(val, key) { return key.toUpperCase() === key; } + * R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4} + */ + var pickBy = _curry2(function pickBy(test, obj) { + var result = {}; + for (var prop in obj) { + if (test(obj[prop], prop, obj)) { + result[prop] = obj[prop]; + } + } + return result; + }); + + /** + * Returns a new list with the given element at the front, followed by the contents of the + * list. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The item to add to the head of the output list. + * @param {Array} list The array to add to the tail of the output list. + * @return {Array} A new array. + * @see R.append + * @example + * + * R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum'] + */ + var prepend = _curry2(function prepend(el, list) { + return _concat([el], list); + }); + + /** + * Returns a function that when supplied an object returns the indicated property of that object, if it exists. + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: a} -> a | Undefined + * @param {String} p The property name + * @param {Object} obj The object to query + * @return {*} The value at `obj.p`. + * @example + * + * R.prop('x', {x: 100}); //=> 100 + * R.prop('x', {}); //=> undefined + */ + var prop = _curry2(function prop(p, obj) { + return obj[p]; + }); + + /** + * If the given, non-null object has an own property with the specified name, + * returns the value of that property. + * Otherwise returns the provided default value. + * + * @func + * @memberOf R + * @category Object + * @sig a -> String -> Object -> a + * @param {*} val The default value. + * @param {String} p The name of the property to return. + * @param {Object} obj The object to query. + * @return {*} The value of given property of the supplied object or the default value. + * @example + * + * var alice = { + * name: 'ALICE', + * age: 101 + * }; + * var favorite = R.prop('favoriteLibrary'); + * var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary'); + * + * favorite(alice); //=> undefined + * favoriteWithDefault(alice); //=> 'Ramda' + */ + var propOr = _curry3(function propOr(val, p, obj) { + return obj != null && _has(p, obj) ? obj[p] : val; + }); + + /** + * Returns `true` if the specified object property satisfies the given + * predicate; `false` otherwise. + * + * @func + * @memberOf R + * @category Logic + * @sig (a -> Boolean) -> String -> {String: a} -> Boolean + * @param {Function} pred + * @param {String} name + * @param {*} obj + * @return {Boolean} + * @see R.propEq + * @see R.propIs + * @example + * + * R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true + */ + var propSatisfies = _curry3(function propSatisfies(pred, name, obj) { + return pred(obj[name]); + }); + + /** + * Acts as multiple `prop`: array of keys in, array of values out. Preserves order. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> [v] + * @param {Array} ps The property names to fetch + * @param {Object} obj The object to query + * @return {Array} The corresponding values or partially applied function. + * @example + * + * R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2] + * R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2] + * + * var fullName = R.compose(R.join(' '), R.props(['first', 'last'])); + * fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth' + */ + var props = _curry2(function props(ps, obj) { + var len = ps.length; + var out = []; + var idx = 0; + while (idx < len) { + out[idx] = obj[ps[idx]]; + idx += 1; + } + return out; + }); + + /** + * Returns a list of numbers from `from` (inclusive) to `to` + * (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [Number] + * @param {Number} from The first number in the list. + * @param {Number} to One more than the last number in the list. + * @return {Array} The list of numbers in tthe set `[a, b)`. + * @example + * + * R.range(1, 5); //=> [1, 2, 3, 4] + * R.range(50, 53); //=> [50, 51, 52] + */ + var range = _curry2(function range(from, to) { + if (!(_isNumber(from) && _isNumber(to))) { + throw new TypeError('Both arguments to range must be numbers'); + } + var result = []; + var n = from; + while (n < to) { + result.push(n); + n += 1; + } + return result; + }); + + /** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * Similar to `reduce`, except moves through the input list from the right to the left. + * + * The iterator function receives two values: *(acc, value)* + * + * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var pairs = [ ['a', 1], ['b', 2], ['c', 3] ]; + * var flattenPairs = function(acc, pair) { + * return acc.concat(pair); + * }; + * + * R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ] + */ + var reduceRight = _curry3(function reduceRight(fn, acc, list) { + var idx = list.length - 1; + while (idx >= 0) { + acc = fn(acc, list[idx]); + idx -= 1; + } + return acc; + }); + + /** + * Returns a value wrapped to indicate that it is the final value of the + * reduce and transduce functions. The returned value + * should be considered a black box: the internal structure is not + * guaranteed to be stable. + * + * Note: this optimization is unavailable to functions not explicitly listed + * above. For instance, it is not currently supported by reduceIndexed, + * reduceRight, or reduceRightIndexed. + * + * @func + * @memberOf R + * @category List + * @see R.reduce, R.transduce + * @sig a -> * + * @param {*} x The final value of the reduce. + * @return {*} The wrapped value. + * @example + * + * R.reduce( + * R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)), + * 0, + * [1, 2, 3, 4, 5]) // 10 + */ + var reduced = _curry1(_reduced); + + /** + * Removes the sub-list of `list` starting at index `start` and containing + * `count` elements. _Note that this is not destructive_: it returns a + * copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @param {Number} start The position to start removing elements + * @param {Number} count The number of elements to remove + * @param {Array} list The list to remove from + * @return {Array} A new Array with `count` elements from `start` removed. + * @example + * + * R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8] + */ + var remove = _curry3(function remove(start, count, list) { + return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count))); + }); + + /** + * Replace a substring or regex match in a string with a replacement. + * + * @func + * @memberOf R + * @category String + * @sig RegExp|String -> String -> String -> String + * @param {RegExp|String} pattern A regular expression or a substring to match. + * @param {String} replacement The string to replace the matches with. + * @param {String} str The String to do the search and replacement in. + * @return {String} The result. + * @example + * + * R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo' + * R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo' + * + * // Use the "g" (global) flag to replace all occurrences: + * R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar' + */ + var replace = _curry3(function replace(regex, replacement, str) { + return str.replace(regex, replacement); + }); + + /** + * Returns a new list with the same elements as the original list, just + * in the reverse order. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The list to reverse. + * @return {Array} A copy of the list in reverse order. + * @example + * + * R.reverse([1, 2, 3]); //=> [3, 2, 1] + * R.reverse([1, 2]); //=> [2, 1] + * R.reverse([1]); //=> [1] + * R.reverse([]); //=> [] + */ + var reverse = _curry1(function reverse(list) { + return _slice(list).reverse(); + }); + + /** + * Scan is similar to reduce, but returns a list of successively reduced values from the left + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> [a] + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {Array} A list of all intermediately reduced values. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24] + */ + var scan = _curry3(function scan(fn, acc, list) { + var idx = 0, len = list.length, result = [acc]; + while (idx < len) { + acc = fn(acc, list[idx]); + result[idx + 1] = acc; + idx += 1; + } + return result; + }); + + /** + * Returns the result of "setting" the portion of the given data structure + * focused by the given lens to the given value. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> a -> s -> s + * @param {Lens} lens + * @param {*} v + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lensProp('x'); + * + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2} + */ + var set = _curry3(function set(lens, v, x) { + return over(lens, always(v), x); + }); + + /** + * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a + * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero + * if they are equal. Please note that this is a **copy** of the list. It does not modify the original. + * + * @func + * @memberOf R + * @category List + * @sig (a,a -> Number) -> [a] -> [a] + * @param {Function} comparator A sorting function :: a -> b -> Int + * @param {Array} list The list to sort + * @return {Array} a new array with its elements sorted by the comparator function. + * @example + * + * var diff = function(a, b) { return a - b; }; + * R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7] + */ + var sort = _curry2(function sort(comparator, list) { + return _slice(list).sort(comparator); + }); + + /** + * Sorts the list according to the supplied function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> [a] -> [a] + * @param {Function} fn + * @param {Array} list The list to sort. + * @return {Array} A new list sorted by the keys generated by `fn`. + * @example + * + * var sortByFirstItem = R.sortBy(prop(0)); + * var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name'))); + * var pairs = [[-1, 1], [-2, 2], [-3, 3]]; + * sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]] + * var alice = { + * name: 'ALICE', + * age: 101 + * }; + * var bob = { + * name: 'Bob', + * age: -10 + * }; + * var clara = { + * name: 'clara', + * age: 314.159 + * }; + * var people = [clara, bob, alice]; + * sortByNameCaseInsensitive(people); //=> [alice, bob, clara] + */ + var sortBy = _curry2(function sortBy(fn, list) { + return _slice(list).sort(function (a, b) { + var aa = fn(a); + var bb = fn(b); + return aa < bb ? -1 : aa > bb ? 1 : 0; + }); + }); + + /** + * Subtracts two numbers. Equivalent to `a - b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a - b`. + * @see R.add + * @example + * + * R.subtract(10, 8); //=> 2 + * + * var minus5 = R.subtract(R.__, 5); + * minus5(17); //=> 12 + * + * var complementaryAngle = R.subtract(90); + * complementaryAngle(30); //=> 60 + * complementaryAngle(72); //=> 18 + */ + var subtract = _curry2(function subtract(a, b) { + return a - b; + }); + + /** + * Returns a new list containing the last `n` elements of a given list, passing each value + * to the supplied predicate function, and terminating when the predicate function returns + * `false`. Excludes the element that caused the predicate function to fail. The predicate + * function is passed one argument: *(value)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.dropLastWhile + * @example + * + * var isNotOne = function(x) { + * return !(x === 1); + * }; + * + * R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4] + */ + var takeLastWhile = _curry2(function takeLastWhile(fn, list) { + var idx = list.length - 1; + while (idx >= 0 && fn(list[idx])) { + idx -= 1; + } + return _slice(list, idx + 1, Infinity); + }); + + /** + * Runs the given function with the supplied object, then returns the object. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> *) -> a -> a + * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away. + * @param {*} x + * @return {*} `x`. + * @example + * + * var sayX = function(x) { console.log('x is ' + x); }; + * R.tap(sayX, 100); //=> 100 + * //-> 'x is 100' + */ + var tap = _curry2(function tap(fn, x) { + fn(x); + return x; + }); + + /** + * Determines whether a given string matches a given regular expression. + * + * @func + * @memberOf R + * @see R.match + * @category String + * @sig RegExp -> String -> Boolean + * @param {RegExp} pattern + * @param {String} str + * @return {Boolean} + * @example + * + * R.test(/^x/, 'xyz'); //=> true + * R.test(/^y/, 'xyz'); //=> false + */ + var test = _curry2(function test(pattern, str) { + return _cloneRegExp(pattern).test(str); + }); + + /** + * Calls an input function `n` times, returning an array containing the results of those + * function calls. + * + * `fn` is passed one argument: The current value of `n`, which begins at `0` and is + * gradually incremented to `n - 1`. + * + * @func + * @memberOf R + * @category List + * @sig (i -> a) -> i -> [a] + * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`. + * @param {Number} n A value between `0` and `n - 1`. Increments after each function call. + * @return {Array} An array containing the return values of all calls to `fn`. + * @example + * + * R.times(R.identity, 5); //=> [0, 1, 2, 3, 4] + */ + var times = _curry2(function times(fn, n) { + var len = Number(n); + var list = new Array(len); + var idx = 0; + while (idx < len) { + list[idx] = fn(idx); + idx += 1; + } + return list; + }); + + /** + * Converts an object into an array of key, value arrays. + * Only the object's own properties are used. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> [[String,*]] + * @param {Object} obj The object to extract from + * @return {Array} An array of key, value arrays from the object's own properties. + * @see R.fromPairs + * @example + * + * R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]] + */ + var toPairs = _curry1(function toPairs(obj) { + var pairs = []; + for (var prop in obj) { + if (_has(prop, obj)) { + pairs[pairs.length] = [ + prop, + obj[prop] + ]; + } + } + return pairs; + }); + + /** + * Converts an object into an array of key, value arrays. + * The object's own properties and prototype properties are used. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> [[String,*]] + * @param {Object} obj The object to extract from + * @return {Array} An array of key, value arrays from the object's own + * and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.toPairsIn(f); //=> [['x','X'], ['y','Y']] + */ + var toPairsIn = _curry1(function toPairsIn(obj) { + var pairs = []; + for (var prop in obj) { + pairs[pairs.length] = [ + prop, + obj[prop] + ]; + } + return pairs; + }); + + /** + * Removes (strips) whitespace from both ends of the string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to trim. + * @return {String} Trimmed version of `str`. + * @example + * + * R.trim(' xyz '); //=> 'xyz' + * R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z'] + */ + var trim = function () { + var ws = '\t\n\x0B\f\r \xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + '\u2029\uFEFF'; + var zeroWidth = '\u200B'; + var hasProtoTrim = typeof String.prototype.trim === 'function'; + if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) { + return _curry1(function trim(str) { + var beginRx = new RegExp('^[' + ws + '][' + ws + ']*'); + var endRx = new RegExp('[' + ws + '][' + ws + ']*$'); + return str.replace(beginRx, '').replace(endRx, ''); + }); + } else { + return _curry1(function trim(str) { + return str.trim(); + }); + } + }(); + + /** + * Gives a single-word string description of the (native) type of a value, returning such + * answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user + * Object types any further, reporting them all as 'Object'. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> String + * @param {*} val The value to test + * @return {String} + * @example + * + * R.type({}); //=> "Object" + * R.type(1); //=> "Number" + * R.type(false); //=> "Boolean" + * R.type('s'); //=> "String" + * R.type(null); //=> "Null" + * R.type([]); //=> "Array" + * R.type(/[A-z]/); //=> "RegExp" + */ + var type = _curry1(function type(val) { + return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1); + }); + + /** + * Takes a function `fn`, which takes a single array argument, and returns + * a function which: + * + * - takes any number of positional arguments; + * - passes these arguments to `fn` as an array; and + * - returns the result. + * + * In other words, R.unapply derives a variadic function from a function + * which takes an array. R.unapply is the inverse of R.apply. + * + * @func + * @memberOf R + * @category Function + * @sig ([*...] -> a) -> (*... -> a) + * @param {Function} fn + * @return {Function} + * @see R.apply + * @example + * + * R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]' + */ + var unapply = _curry1(function unapply(fn) { + return function () { + return fn(_slice(arguments)); + }; + }); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly 1 + * parameter. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> b) -> (a -> b) + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity 1. + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.unary(takesTwoArgs); + * takesOneArg.length; //=> 1 + * // Only 1 argument is passed to the wrapped function + * takesOneArg(1, 2); //=> [1, undefined] + */ + var unary = _curry1(function unary(fn) { + return nAry(1, fn); + }); + + /** + * Returns a function of arity `n` from a (manually) curried function. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (a -> b) -> (a -> c) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to uncurry. + * @return {Function} A new function. + * @see R.curry + * @example + * + * var addFour = function(a) { + * return function(b) { + * return function(c) { + * return function(d) { + * return a + b + c + d; + * }; + * }; + * }; + * }; + * + * var uncurriedAddFour = R.uncurryN(4, addFour); + * curriedAddFour(1, 2, 3, 4); //=> 10 + */ + var uncurryN = _curry2(function uncurryN(depth, fn) { + return curryN(depth, function () { + var currentDepth = 1; + var value = fn; + var idx = 0; + var endIdx; + while (currentDepth <= depth && typeof value === 'function') { + endIdx = currentDepth === depth ? arguments.length : idx + value.length; + value = value.apply(this, _slice(arguments, idx, endIdx)); + currentDepth += 1; + idx = endIdx; + } + return value; + }); + }); + + /** + * Builds a list from a seed value. Accepts an iterator function, which returns either false + * to stop iteration or an array of length 2 containing the value to add to the resulting + * list and the seed to be used in the next call to the iterator function. + * + * The iterator function receives one argument: *(seed)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> [b]) -> * -> [b] + * @param {Function} fn The iterator function. receives one argument, `seed`, and returns + * either false to quit iteration or an array of length two to proceed. The element + * at index 0 of this array will be added to the resulting array, and the element + * at index 1 will be passed to the next call to `fn`. + * @param {*} seed The seed value. + * @return {Array} The final list. + * @example + * + * var f = function(n) { return n > 50 ? false : [-n, n + 10] }; + * R.unfold(f, 10); //=> [-10, -20, -30, -40, -50] + */ + var unfold = _curry2(function unfold(fn, seed) { + var pair = fn(seed); + var result = []; + while (pair && pair.length) { + result[result.length] = pair[0]; + pair = fn(pair[1]); + } + return result; + }); + + /** + * Returns a new list containing only one copy of each element in the original list, based + * upon the value returned by applying the supplied predicate to two list elements. Prefers + * the first item if two items compare equal based on the predicate. + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * var strEq = function(a, b) { return String(a) === String(b); }; + * R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2] + * R.uniqWith(strEq)([{}, {}]); //=> [{}] + * R.uniqWith(strEq)([1, '1', 1]); //=> [1] + * R.uniqWith(strEq)(['1', 1, 1]); //=> ['1'] + */ + var uniqWith = _curry2(function uniqWith(pred, list) { + var idx = 0, len = list.length; + var result = [], item; + while (idx < len) { + item = list[idx]; + if (!_containsWith(pred, item, result)) { + result[result.length] = item; + } + idx += 1; + } + return result; + }); + + /** + * Returns a new copy of the array with the element at the + * provided index replaced with the given value. + * @see R.adjust + * + * @func + * @memberOf R + * @category List + * @sig Number -> a -> [a] -> [a] + * @param {Number} idx The index to update. + * @param {*} x The value to exist at the given index of the returned array. + * @param {Array|Arguments} list The source array-like object to be updated. + * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`. + * @example + * + * R.update(1, 11, [0, 1, 2]); //=> [0, 11, 2] + * R.update(1)(11)([0, 1, 2]); //=> [0, 11, 2] + */ + var update = _curry3(function update(idx, x, list) { + return adjust(always(x), idx, list); + }); + + /** + * Returns a list of all the enumerable own properties of the supplied object. + * Note that the order of the output array is not guaranteed across + * different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [v] + * @param {Object} obj The object to extract values from + * @return {Array} An array of the values of the object's own properties. + * @example + * + * R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3] + */ + var values = _curry1(function values(obj) { + var props = keys(obj); + var len = props.length; + var vals = []; + var idx = 0; + while (idx < len) { + vals[idx] = obj[props[idx]]; + idx += 1; + } + return vals; + }); + + /** + * Returns a list of all the properties, including prototype properties, + * of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [v] + * @param {Object} obj The object to extract values from + * @return {Array} An array of the values of the object's own and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.valuesIn(f); //=> ['X', 'Y'] + */ + var valuesIn = _curry1(function valuesIn(obj) { + var prop, vs = []; + for (prop in obj) { + vs[vs.length] = obj[prop]; + } + return vs; + }); + + /** + * Returns a "view" of the given data structure, determined by the given lens. + * The lens's focus determines which portion of the data structure is visible. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> s -> a + * @param {Lens} lens + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lensProp('x'); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.view(xLens, {x: 4, y: 2}); //=> 4 + */ + var view = function () { + var Const = function (x) { + return { + value: x, + map: function () { + return this; + } + }; + }; + return _curry2(function view(lens, x) { + return lens(Const)(x).value; + }); + }(); + + /** + * Takes a spec object and a test object; returns true if the test satisfies + * the spec. Each of the spec's own properties must be a predicate function. + * Each predicate is applied to the value of the corresponding property of + * the test object. `where` returns true if all the predicates return true, + * false otherwise. + * + * `where` is well suited to declaratively expressing constraints for other + * functions such as `filter` and `find`. + * + * @func + * @memberOf R + * @category Object + * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean + * @param {Object} spec + * @param {Object} testObj + * @return {Boolean} + * @example + * + * // pred :: Object -> Boolean + * var pred = R.where({ + * a: R.equals('foo'), + * b: R.complement(R.equals('bar')), + * x: R.gt(_, 10), + * y: R.lt(_, 20) + * }); + * + * pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true + * pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false + * pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false + * pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false + * pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false + */ + var where = _curry2(function where(spec, testObj) { + for (var prop in spec) { + if (_has(prop, spec) && !spec[prop](testObj[prop])) { + return false; + } + } + return true; + }); + + /** + * Wrap a function inside another to allow you to make adjustments to the parameters, or do + * other processing either before the internal function is called or with its results. + * + * @func + * @memberOf R + * @category Function + * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c) + * @param {Function} fn The function to wrap. + * @param {Function} wrapper The wrapper function. + * @return {Function} The wrapped function. + * @example + * + * var greet = function(name) {return 'Hello ' + name;}; + * + * var shoutedGreet = R.wrap(greet, function(gr, name) { + * return gr(name).toUpperCase(); + * }); + * shoutedGreet("Kathy"); //=> "HELLO KATHY" + * + * var shortenedGreet = R.wrap(greet, function(gr, name) { + * return gr(name.substring(0, 3)); + * }); + * shortenedGreet("Robert"); //=> "Hello Rob" + */ + var wrap = _curry2(function wrap(fn, wrapper) { + return curryN(fn.length, function () { + return wrapper.apply(this, _concat([fn], arguments)); + }); + }); + + /** + * Creates a new list out of the two supplied by creating each possible + * pair from the lists. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] -> [[a,b]] + * @param {Array} as The first list. + * @param {Array} bs The second list. + * @return {Array} The list made by combining each possible pair from + * `as` and `bs` into pairs (`[a, b]`). + * @example + * + * R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']] + */ + // = xprodWith(prepend); (takes about 3 times as long...) + var xprod = _curry2(function xprod(a, b) { + // = xprodWith(prepend); (takes about 3 times as long...) + var idx = 0; + var ilen = a.length; + var j; + var jlen = b.length; + var result = []; + while (idx < ilen) { + j = 0; + while (j < jlen) { + result[result.length] = [ + a[idx], + b[j] + ]; + j += 1; + } + idx += 1; + } + return result; + }); + + /** + * Creates a new list out of the two supplied by pairing up + * equally-positioned items from both lists. The returned list is + * truncated to the length of the shorter of the two input lists. + * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] -> [[a,b]] + * @param {Array} list1 The first array to consider. + * @param {Array} list2 The second array to consider. + * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`. + * @example + * + * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']] + */ + var zip = _curry2(function zip(a, b) { + var rv = []; + var idx = 0; + var len = Math.min(a.length, b.length); + while (idx < len) { + rv[idx] = [ + a[idx], + b[idx] + ]; + idx += 1; + } + return rv; + }); + + /** + * Creates a new object out of a list of keys and a list of values. + * + * @func + * @memberOf R + * @category List + * @sig [String] -> [*] -> {String: *} + * @param {Array} keys The array that will be properties on the output object. + * @param {Array} values The list of values on the output object. + * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`. + * @example + * + * R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3} + */ + var zipObj = _curry2(function zipObj(keys, values) { + var idx = 0, len = keys.length, out = {}; + while (idx < len) { + out[keys[idx]] = values[idx]; + idx += 1; + } + return out; + }); + + /** + * Creates a new list out of the two supplied by applying the function to + * each equally-positioned pair in the lists. The returned list is + * truncated to the length of the shorter of the two input lists. + * + * @function + * @memberOf R + * @category List + * @sig (a,b -> c) -> [a] -> [b] -> [c] + * @param {Function} fn The function used to combine the two elements into one value. + * @param {Array} list1 The first array to consider. + * @param {Array} list2 The second array to consider. + * @return {Array} The list made by combining same-indexed elements of `list1` and `list2` + * using `fn`. + * @example + * + * var f = function(x, y) { + * // ... + * }; + * R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']); + * //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')] + */ + var zipWith = _curry3(function zipWith(fn, a, b) { + var rv = [], idx = 0, len = Math.min(a.length, b.length); + while (idx < len) { + rv[idx] = fn(a[idx], b[idx]); + idx += 1; + } + return rv; + }); + + /** + * A function that always returns `false`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> false + * @return {Boolean} false + * @see R.always, R.T + * @example + * + * R.F(); //=> false + */ + var F = always(false); + + /** + * A function that always returns `true`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> true + * @return {Boolean} `true`. + * @see R.always, R.F + * @example + * + * R.T(); //=> true + */ + var T = always(true); + + /** + * Similar to hasMethod, this checks whether a function has a [methodname] + * function. If it isn't an array it will execute that function otherwise it will + * default to the ramda implementation. + * + * @private + * @param {Function} fn ramda implemtation + * @param {String} methodname property to check for a custom implementation + * @return {Object} Whatever the return value of the method is. + */ + var _checkForMethod = function _checkForMethod(methodname, fn) { + return function () { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1)); + }; + }; + + /** + * Copies an object. + * + * @private + * @param {*} value The value to be copied + * @param {Array} refFrom Array containing the source references + * @param {Array} refTo Array containing the copied source references + * @return {*} The copied value. + */ + var _clone = function _clone(value, refFrom, refTo) { + var copy = function copy(copiedValue) { + var len = refFrom.length; + var idx = 0; + while (idx < len) { + if (value === refFrom[idx]) { + return refTo[idx]; + } + idx += 1; + } + refFrom[idx + 1] = value; + refTo[idx + 1] = copiedValue; + for (var key in value) { + copiedValue[key] = _clone(value[key], refFrom, refTo); + } + return copiedValue; + }; + switch (type(value)) { + case 'Object': + return copy({}); + case 'Array': + return copy([]); + case 'Date': + return new Date(value); + case 'RegExp': + return _cloneRegExp(value); + default: + return value; + } + }; + + var _createPartialApplicator = function _createPartialApplicator(concat) { + return function (fn) { + var args = _slice(arguments, 1); + return _arity(Math.max(0, fn.length - args.length), function () { + return fn.apply(this, concat(args, arguments)); + }); + }; + }; + + /** + * Returns a function that dispatches with different strategies based on the + * object in list position (last argument). If it is an array, executes [fn]. + * Otherwise, if it has a function with [methodname], it will execute that + * function (functor case). Otherwise, if it is a transformer, uses transducer + * [xf] to return a new transformer (transducer case). Otherwise, it will + * default to executing [fn]. + * + * @private + * @param {String} methodname property to check for a custom implementation + * @param {Function} xf transducer to initialize if object is transformer + * @param {Function} fn default ramda implementation + * @return {Function} A function that dispatches on object in list position + */ + var _dispatchable = function _dispatchable(methodname, xf, fn) { + return function () { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + if (!_isArray(obj)) { + var args = _slice(arguments, 0, length - 1); + if (typeof obj[methodname] === 'function') { + return obj[methodname].apply(obj, args); + } + if (_isTransformer(obj)) { + var transducer = xf.apply(null, args); + return transducer(obj); + } + } + return fn.apply(this, arguments); + }; + }; + + // The algorithm used to handle cyclic structures is + // inspired by underscore's isEqual + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + var _equals = function _equals(a, b, stackA, stackB) { + var typeA = type(a); + if (typeA !== type(b)) { + return false; + } + if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') { + return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b); + } + if (identical(a, b)) { + return true; + } + if (typeA === 'RegExp') { + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode; + } + if (Object(a) === a) { + if (typeA === 'Date' && a.getTime() !== b.getTime()) { + return false; + } + var keysA = keys(a); + if (keysA.length !== keys(b).length) { + return false; + } + var idx = stackA.length - 1; + while (idx >= 0) { + if (stackA[idx] === a) { + return stackB[idx] === b; + } + idx -= 1; + } + stackA[stackA.length] = a; + stackB[stackB.length] = b; + idx = keysA.length - 1; + while (idx >= 0) { + var key = keysA[idx]; + if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) { + return false; + } + idx -= 1; + } + stackA.pop(); + stackB.pop(); + return true; + } + return false; + }; + + /** + * Private function that determines whether or not a provided object has a given method. + * Does not ignore methods stored on the object's prototype chain. Used for dynamically + * dispatching Ramda methods to non-Array objects. + * + * @private + * @param {String} methodName The name of the method to check for. + * @param {Object} obj The object to test. + * @return {Boolean} `true` has a given method, `false` otherwise. + * @example + * + * var person = { name: 'John' }; + * person.shout = function() { alert(this.name); }; + * + * _hasMethod('shout', person); //=> true + * _hasMethod('foo', person); //=> false + */ + var _hasMethod = function _hasMethod(methodName, obj) { + return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function'; + }; + + /** + * `_makeFlat` is a helper function that returns a one-level or fully recursive function + * based on the flag passed in. + * + * @private + */ + var _makeFlat = function _makeFlat(recursive) { + return function flatt(list) { + var value, result = [], idx = 0, j, ilen = list.length, jlen; + while (idx < ilen) { + if (isArrayLike(list[idx])) { + value = recursive ? flatt(list[idx]) : list[idx]; + j = 0; + jlen = value.length; + while (j < jlen) { + result[result.length] = value[j]; + j += 1; + } + } else { + result[result.length] = list[idx]; + } + idx += 1; + } + return result; + }; + }; + + var _reduce = function () { + function _arrayReduce(xf, acc, list) { + var idx = 0, len = list.length; + while (idx < len) { + acc = xf['@@transducer/step'](acc, list[idx]); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + idx += 1; + } + return xf['@@transducer/result'](acc); + } + function _iterableReduce(xf, acc, iter) { + var step = iter.next(); + while (!step.done) { + acc = xf['@@transducer/step'](acc, step.value); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + step = iter.next(); + } + return xf['@@transducer/result'](acc); + } + function _methodReduce(xf, acc, obj) { + return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc)); + } + var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator'; + return function _reduce(fn, acc, list) { + if (typeof fn === 'function') { + fn = _xwrap(fn); + } + if (isArrayLike(list)) { + return _arrayReduce(fn, acc, list); + } + if (typeof list.reduce === 'function') { + return _methodReduce(fn, acc, list); + } + if (list[symIterator] != null) { + return _iterableReduce(fn, acc, list[symIterator]()); + } + if (typeof list.next === 'function') { + return _iterableReduce(fn, acc, list); + } + throw new TypeError('reduce: list must be array or iterable'); + }; + }(); + + var _stepCat = function () { + var _stepCatArray = { + '@@transducer/init': Array, + '@@transducer/step': function (xs, x) { + return _concat(xs, [x]); + }, + '@@transducer/result': _identity + }; + var _stepCatString = { + '@@transducer/init': String, + '@@transducer/step': function (a, b) { + return a + b; + }, + '@@transducer/result': _identity + }; + var _stepCatObject = { + '@@transducer/init': Object, + '@@transducer/step': function (result, input) { + return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input); + }, + '@@transducer/result': _identity + }; + return function _stepCat(obj) { + if (_isTransformer(obj)) { + return obj; + } + if (isArrayLike(obj)) { + return _stepCatArray; + } + if (typeof obj === 'string') { + return _stepCatString; + } + if (typeof obj === 'object') { + return _stepCatObject; + } + throw new Error('Cannot create transformer for ' + obj); + }; + }(); + + var _xall = function () { + function XAll(f, xf) { + this.xf = xf; + this.f = f; + this.all = true; + } + XAll.prototype['@@transducer/init'] = _xfBase.init; + XAll.prototype['@@transducer/result'] = function (result) { + if (this.all) { + result = this.xf['@@transducer/step'](result, true); + } + return this.xf['@@transducer/result'](result); + }; + XAll.prototype['@@transducer/step'] = function (result, input) { + if (!this.f(input)) { + this.all = false; + result = _reduced(this.xf['@@transducer/step'](result, false)); + } + return result; + }; + return _curry2(function _xall(f, xf) { + return new XAll(f, xf); + }); + }(); + + var _xany = function () { + function XAny(f, xf) { + this.xf = xf; + this.f = f; + this.any = false; + } + XAny.prototype['@@transducer/init'] = _xfBase.init; + XAny.prototype['@@transducer/result'] = function (result) { + if (!this.any) { + result = this.xf['@@transducer/step'](result, false); + } + return this.xf['@@transducer/result'](result); + }; + XAny.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.any = true; + result = _reduced(this.xf['@@transducer/step'](result, true)); + } + return result; + }; + return _curry2(function _xany(f, xf) { + return new XAny(f, xf); + }); + }(); + + var _xdrop = function () { + function XDrop(n, xf) { + this.xf = xf; + this.n = n; + } + XDrop.prototype['@@transducer/init'] = _xfBase.init; + XDrop.prototype['@@transducer/result'] = _xfBase.result; + XDrop.prototype['@@transducer/step'] = function (result, input) { + if (this.n > 0) { + this.n -= 1; + return result; + } + return this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdrop(n, xf) { + return new XDrop(n, xf); + }); + }(); + + var _xdropWhile = function () { + function XDropWhile(f, xf) { + this.xf = xf; + this.f = f; + } + XDropWhile.prototype['@@transducer/init'] = _xfBase.init; + XDropWhile.prototype['@@transducer/result'] = _xfBase.result; + XDropWhile.prototype['@@transducer/step'] = function (result, input) { + if (this.f) { + if (this.f(input)) { + return result; + } + this.f = null; + } + return this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdropWhile(f, xf) { + return new XDropWhile(f, xf); + }); + }(); + + var _xgroupBy = function () { + function XGroupBy(f, xf) { + this.xf = xf; + this.f = f; + this.inputs = {}; + } + XGroupBy.prototype['@@transducer/init'] = _xfBase.init; + XGroupBy.prototype['@@transducer/result'] = function (result) { + var key; + for (key in this.inputs) { + if (_has(key, this.inputs)) { + result = this.xf['@@transducer/step'](result, this.inputs[key]); + if (result['@@transducer/reduced']) { + result = result['@@transducer/value']; + break; + } + } + } + return this.xf['@@transducer/result'](result); + }; + XGroupBy.prototype['@@transducer/step'] = function (result, input) { + var key = this.f(input); + this.inputs[key] = this.inputs[key] || [ + key, + [] + ]; + this.inputs[key][1] = append(input, this.inputs[key][1]); + return result; + }; + return _curry2(function _xgroupBy(f, xf) { + return new XGroupBy(f, xf); + }); + }(); + + /** + * Creates a new list iteration function from an existing one by adding two new parameters + * to its callback function: the current index, and the entire list. + * + * This would turn, for instance, Ramda's simple `map` function into one that more closely + * resembles `Array.prototype.map`. Note that this will only work for functions in which + * the iteration callback function is the first parameter, and where the list is the last + * parameter. (This latter might be unimportant if the list parameter is not used.) + * + * @func + * @memberOf R + * @category Function + * @category List + * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *) + * @param {Function} fn A list iteration function that does not pass index or list to its callback + * @return {Function} An altered list iteration function that passes (item, index, list) to its callback + * @example + * + * var mapIndexed = R.addIndex(R.map); + * mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']); + * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r'] + */ + var addIndex = _curry1(function addIndex(fn) { + return curryN(fn.length, function () { + var idx = 0; + var origFn = arguments[0]; + var list = arguments[arguments.length - 1]; + var args = _slice(arguments); + args[0] = function () { + var result = origFn.apply(this, _concat(arguments, [ + idx, + list + ])); + idx += 1; + return result; + }; + return fn.apply(this, args); + }); + }); + + /** + * Returns `true` if all elements of the list match the predicate, `false` if there are any + * that don't. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is satisfied by every element, `false` + * otherwise. + * @see R.any, R.none + * @example + * + * var lessThan2 = R.flip(R.lt)(2); + * var lessThan3 = R.flip(R.lt)(3); + * R.all(lessThan2)([1, 2]); //=> false + * R.all(lessThan3)([1, 2]); //=> true + */ + var all = _curry2(_dispatchable('all', _xall, function all(fn, list) { + var idx = 0; + while (idx < list.length) { + if (!fn(list[idx])) { + return false; + } + idx += 1; + } + return true; + })); + + /** + * A function that returns the first argument if it's falsy otherwise the second + * argument. Note that this is NOT short-circuited, meaning that if expressions + * are passed they are both evaluated. + * + * Dispatches to the `and` method of the first argument if applicable. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> * -> * + * @param {*} a any value + * @param {*} b any other value + * @return {*} the first argument if falsy otherwise the second argument. + * @see R.both + * @example + * + * R.and(false, true); //=> false + * R.and(0, []); //=> 0 + * R.and(null, ''); => null + */ + var and = _curry2(function and(a, b) { + return _hasMethod('and', a) ? a.and(b) : a && b; + }); + + /** + * Returns `true` if at least one of elements of the list match the predicate, `false` + * otherwise. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false` + * otherwise. + * @see R.all, R.none + * @example + * + * var lessThan0 = R.flip(R.lt)(0); + * var lessThan2 = R.flip(R.lt)(2); + * R.any(lessThan0)([1, 2]); //=> false + * R.any(lessThan2)([1, 2]); //=> true + */ + var any = _curry2(_dispatchable('any', _xany, function any(fn, list) { + var idx = 0; + while (idx < list.length) { + if (fn(list[idx])) { + return true; + } + idx += 1; + } + return false; + })); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly 2 + * parameters. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> c) -> (a, b -> c) + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity 2. + * @example + * + * var takesThreeArgs = function(a, b, c) { + * return [a, b, c]; + * }; + * takesThreeArgs.length; //=> 3 + * takesThreeArgs(1, 2, 3); //=> [1, 2, 3] + * + * var takesTwoArgs = R.binary(takesThreeArgs); + * takesTwoArgs.length; //=> 2 + * // Only 2 arguments are passed to the wrapped function + * takesTwoArgs(1, 2, 3); //=> [1, 2, undefined] + */ + var binary = _curry1(function binary(fn) { + return nAry(2, fn); + }); + + /** + * Creates a deep copy of the value which may contain (nested) `Array`s and + * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are + * not copied, but assigned by their reference. + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> {*} + * @param {*} value The object or array to clone + * @return {*} A new object or array. + * @example + * + * var objects = [{}, {}, {}]; + * var objectsClone = R.clone(objects); + * objects[0] === objectsClone[0]; //=> false + */ + var clone = _curry1(function clone(value) { + return _clone(value, [], []); + }); + + /** + * Returns a new list consisting of the elements of the first list followed by the elements + * of the second. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list to merge. + * @param {Array} list2 The second set to merge. + * @return {Array} A new array consisting of the contents of `list1` followed by the + * contents of `list2`. If, instead of an Array for `list1`, you pass an + * object with a `concat` method on it, `concat` will call `list1.concat` + * and pass it the value of `list2`. + * + * @example + * + * R.concat([], []); //=> [] + * R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + * R.concat('ABC', 'DEF'); // 'ABCDEF' + */ + var concat = _curry2(function concat(set1, set2) { + if (_isArray(set2)) { + return _concat(set1, set2); + } else if (_hasMethod('concat', set1)) { + return set1.concat(set2); + } else { + throw new TypeError('can\'t concat ' + typeof set1); + } + }); + + /** + * Returns a curried equivalent of the provided function. The curried + * function has two unusual capabilities. First, its arguments needn't + * be provided one at a time. If `f` is a ternary function and `g` is + * `R.curry(f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig (* -> a) -> (* -> a) + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curryN + * @example + * + * var addFourNumbers = function(a, b, c, d) { + * return a + b + c + d; + * }; + * + * var curriedAddFourNumbers = R.curry(addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ + var curry = _curry1(function curry(fn) { + return curryN(fn.length, fn); + }); + + /** + * Returns a new list containing the last `n` elements of a given list, passing each value + * to the supplied predicate function, skipping elements while the predicate function returns + * `true`. The predicate function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.takeWhile + * @example + * + * var lteTwo = function(x) { + * return x <= 2; + * }; + * + * R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1] + */ + var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) { + var idx = 0, len = list.length; + while (idx < len && pred(list[idx])) { + idx += 1; + } + return _slice(list, idx); + })); + + /** + * Returns `true` if its arguments are equivalent, `false` otherwise. + * Dispatches to an `equals` method if present. Handles cyclical data + * structures. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> b -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * R.equals(1, 1); //=> true + * R.equals(1, '1'); //=> false + * R.equals([1, 2, 3], [1, 2, 3]); //=> true + * + * var a = {}; a.v = a; + * var b = {}; b.v = b; + * R.equals(a, b); //=> true + */ + var equals = _curry2(function equals(a, b) { + return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []); + }); + + /** + * Returns a new list containing only those items that match a given predicate function. + * The predicate function is passed one argument: *(value)*. + * + * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native + * `Array.prototype.filter` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.reject + * @example + * + * var isEven = function(n) { + * return n % 2 === 0; + * }; + * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4] + */ + var filter = _curry2(_dispatchable('filter', _xfilter, _filter)); + + /** + * Returns the first element of the list which matches the predicate, or `undefined` if no + * element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> a | undefined + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Object} The element found, or `undefined`. + * @example + * + * var xs = [{a: 1}, {a: 2}, {a: 3}]; + * R.find(R.propEq('a', 2))(xs); //=> {a: 2} + * R.find(R.propEq('a', 4))(xs); //=> undefined + */ + var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) { + var idx = 0; + var len = list.length; + while (idx < len) { + if (fn(list[idx])) { + return list[idx]; + } + idx += 1; + } + })); + + /** + * Returns the index of the first element of the list which matches the predicate, or `-1` + * if no element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Number + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Number} The index of the element found, or `-1`. + * @example + * + * var xs = [{a: 1}, {a: 2}, {a: 3}]; + * R.findIndex(R.propEq('a', 2))(xs); //=> 1 + * R.findIndex(R.propEq('a', 4))(xs); //=> -1 + */ + var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) { + var idx = 0; + var len = list.length; + while (idx < len) { + if (fn(list[idx])) { + return idx; + } + idx += 1; + } + return -1; + })); + + /** + * Returns the last element of the list which matches the predicate, or `undefined` if no + * element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> a | undefined + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Object} The element found, or `undefined`. + * @example + * + * var xs = [{a: 1, b: 0}, {a:1, b: 1}]; + * R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1} + * R.findLast(R.propEq('a', 4))(xs); //=> undefined + */ + var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) { + var idx = list.length - 1; + while (idx >= 0) { + if (fn(list[idx])) { + return list[idx]; + } + idx -= 1; + } + })); + + /** + * Returns the index of the last element of the list which matches the predicate, or + * `-1` if no element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Number + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Number} The index of the element found, or `-1`. + * @example + * + * var xs = [{a: 1, b: 0}, {a:1, b: 1}]; + * R.findLastIndex(R.propEq('a', 1))(xs); //=> 1 + * R.findLastIndex(R.propEq('a', 4))(xs); //=> -1 + */ + var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) { + var idx = list.length - 1; + while (idx >= 0) { + if (fn(list[idx])) { + return idx; + } + idx -= 1; + } + return -1; + })); + + /** + * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting + * them in a new array, depth-first. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] + * @param {Array} list The array to consider. + * @return {Array} The flattened list. + * @see R.unnest + * @example + * + * R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]); + * //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + */ + var flatten = _curry1(_makeFlat(true)); + + /** + * Returns a new function much like the supplied one, except that the first two arguments' + * order is reversed. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z) + * @param {Function} fn The function to invoke with its first two parameters reversed. + * @return {*} The result of invoking `fn` with its first two parameters' order reversed. + * @example + * + * var mergeThree = function(a, b, c) { + * return ([]).concat(a, b, c); + * }; + * + * mergeThree(1, 2, 3); //=> [1, 2, 3] + * + * R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3] + */ + var flip = _curry1(function flip(fn) { + return curry(function (a, b) { + var args = _slice(arguments); + args[0] = b; + args[1] = a; + return fn.apply(this, args); + }); + }); + + /** + * Iterate over an input `list`, calling a provided function `fn` for each element in the + * list. + * + * `fn` receives one argument: *(value)*. + * + * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.forEach` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description + * + * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original + * array. In some libraries this function is named `each`. + * + * @func + * @memberOf R + * @category List + * @sig (a -> *) -> [a] -> [a] + * @param {Function} fn The function to invoke. Receives one argument, `value`. + * @param {Array} list The list to iterate over. + * @return {Array} The original list. + * @example + * + * var printXPlusFive = function(x) { console.log(x + 5); }; + * R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3] + * //-> 6 + * //-> 7 + * //-> 8 + */ + var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) { + var len = list.length; + var idx = 0; + while (idx < len) { + fn(list[idx]); + idx += 1; + } + return list; + })); + + /** + * Returns a list of function names of object's own functions + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> [String] + * @param {Object} obj The objects with functions in it + * @return {Array} A list of the object's own properties that map to functions. + * @example + * + * R.functions(R); // returns list of ramda's own function names + * + * var F = function() { this.x = function(){}; this.y = 1; } + * F.prototype.z = function() {}; + * F.prototype.a = 100; + * R.functions(new F()); //=> ["x"] + */ + var functions = _curry1(_functionsWith(keys)); + + /** + * Returns a list of function names of object's own and prototype functions + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> [String] + * @param {Object} obj The objects with functions in it + * @return {Array} A list of the object's own properties and prototype + * properties that map to functions. + * @example + * + * R.functionsIn(R); // returns list of ramda's own and prototype function names + * + * var F = function() { this.x = function(){}; this.y = 1; } + * F.prototype.z = function() {}; + * F.prototype.a = 100; + * R.functionsIn(new F()); //=> ["x", "z"] + */ + var functionsIn = _curry1(_functionsWith(keysIn)); + + /** + * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function + * on each element, and grouping the results according to values returned. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> String) -> [a] -> {String: [a]} + * @param {Function} fn Function :: a -> String + * @param {Array} list The array to group + * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements + * that produced that key when passed to `fn`. + * @example + * + * var byGrade = R.groupBy(function(student) { + * var score = student.score; + * return score < 65 ? 'F' : + * score < 70 ? 'D' : + * score < 80 ? 'C' : + * score < 90 ? 'B' : 'A'; + * }); + * var students = [{name: 'Abby', score: 84}, + * {name: 'Eddy', score: 58}, + * // ... + * {name: 'Jack', score: 69}]; + * byGrade(students); + * // { + * // 'A': [{name: 'Dianne', score: 99}], + * // 'B': [{name: 'Abby', score: 84}] + * // // ..., + * // 'F': [{name: 'Eddy', score: 58}] + * // } + */ + var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) { + return _reduce(function (acc, elt) { + var key = fn(elt); + acc[key] = append(elt, acc[key] || (acc[key] = [])); + return acc; + }, {}, list); + })); + + /** + * Returns the first element of the given list or string. In some libraries + * this function is named `first`. + * + * @func + * @memberOf R + * @category List + * @see R.tail, R.init, R.last + * @sig [a] -> a | Undefined + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.head(['fi', 'fo', 'fum']); //=> 'fi' + * R.head([]); //=> undefined + * + * R.head('abc'); //=> 'a' + * R.head(''); //=> '' + */ + var head = nth(0); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of those + * elements common to both lists. Duplication is determined according + * to the value returned by applying the supplied predicate to two list + * elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate function that determines whether + * the two supplied elements are equal. + * @param {Array} list1 One list of items to compare + * @param {Array} list2 A second list of items to compare + * @see R.intersection + * @return {Array} A new list containing those elements common to both lists. + * @example + * + * var buffaloSpringfield = [ + * {id: 824, name: 'Richie Furay'}, + * {id: 956, name: 'Dewey Martin'}, + * {id: 313, name: 'Bruce Palmer'}, + * {id: 456, name: 'Stephen Stills'}, + * {id: 177, name: 'Neil Young'} + * ]; + * var csny = [ + * {id: 204, name: 'David Crosby'}, + * {id: 456, name: 'Stephen Stills'}, + * {id: 539, name: 'Graham Nash'}, + * {id: 177, name: 'Neil Young'} + * ]; + * + * var sameId = function(o1, o2) {return o1.id === o2.id;}; + * + * R.intersectionWith(sameId, buffaloSpringfield, csny); + * //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}] + */ + var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) { + var results = [], idx = 0; + while (idx < list1.length) { + if (_containsWith(pred, list1[idx], list2)) { + results[results.length] = list1[idx]; + } + idx += 1; + } + return uniqWith(pred, results); + }); + + /** + * Creates a new list with the separator interposed between elements. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} separator The element to add to the list. + * @param {Array} list The list to be interposed. + * @return {Array} The new list. + * @example + * + * R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a'] + */ + var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) { + var out = []; + var idx = 0; + var length = list.length; + while (idx < length) { + if (idx === length - 1) { + out.push(list[idx]); + } else { + out.push(list[idx], separator); + } + idx += 1; + } + return out; + })); + + /** + * Transforms the items of the list with the transducer and appends the transformed items to + * the accumulator using an appropriate iterator function based on the accumulator type. + * + * The accumulator can be an array, string, object or a transformer. Iterated items will + * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item + * arrays will be merged as key, value pairs. + * + * The accumulator can also be a transformer object that provides a 2-arity reducing iterator + * function, step, 0-arity initial value function, init, and 1-arity result extraction function + * result. The step function is used as the iterator function in reduce. The result function is + * used to convert the final accumulator into the return type and in most cases is R.identity. + * The init function is used to provide the initial accumulator. + * + * The iteration is performed with R.reduce after initializing the transducer. + * + * @func + * @memberOf R + * @category List + * @sig a -> (b -> b) -> [c] -> a + * @param {*} acc The initial accumulator value. + * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var transducer = R.compose(R.map(R.add(1)), R.take(2)); + * + * R.into([], transducer, numbers); //=> [2, 3] + * + * var intoArray = R.into([]); + * intoArray(transducer, numbers); //=> [2, 3] + */ + var into = _curry3(function into(acc, xf, list) { + return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list); + }); + + /** + * Same as R.invertObj, however this accounts for objects + * with duplicate values by putting the values into an + * array. + * + * @func + * @memberOf R + * @category Object + * @sig {s: x} -> {x: [ s, ... ]} + * @param {Object} obj The object or array to invert + * @return {Object} out A new object with keys + * in an array. + * @example + * + * var raceResultsByFirstName = { + * first: 'alice', + * second: 'jake', + * third: 'alice', + * }; + * R.invert(raceResultsByFirstName); + * //=> { 'alice': ['first', 'third'], 'jake':['second'] } + */ + var invert = _curry1(function invert(obj) { + var props = keys(obj); + var len = props.length; + var idx = 0; + var out = {}; + while (idx < len) { + var key = props[idx]; + var val = obj[key]; + var list = _has(val, out) ? out[val] : out[val] = []; + list[list.length] = key; + idx += 1; + } + return out; + }); + + /** + * Returns a new object with the keys of the given object + * as values, and the values of the given object as keys. + * + * @func + * @memberOf R + * @category Object + * @sig {s: x} -> {x: s} + * @param {Object} obj The object or array to invert + * @return {Object} out A new object + * @example + * + * var raceResults = { + * first: 'alice', + * second: 'jake' + * }; + * R.invertObj(raceResults); + * //=> { 'alice': 'first', 'jake':'second' } + * + * // Alternatively: + * var raceResults = ['alice', 'jake']; + * R.invertObj(raceResults); + * //=> { 'alice': '0', 'jake':'1' } + */ + var invertObj = _curry1(function invertObj(obj) { + var props = keys(obj); + var len = props.length; + var idx = 0; + var out = {}; + while (idx < len) { + var key = props[idx]; + out[obj[key]] = key; + idx += 1; + } + return out; + }); + + /** + * Returns the last element of the given list or string. + * + * @func + * @memberOf R + * @category List + * @see R.init, R.head, R.tail + * @sig [a] -> a | Undefined + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.last(['fi', 'fo', 'fum']); //=> 'fum' + * R.last([]); //=> undefined + * + * R.last('abc'); //=> 'c' + * R.last(''); //=> '' + */ + var last = nth(-1); + + /** + * Returns the position of the last occurrence of an item in + * an array, or -1 if the item is not included in the array. + * `R.equals` is used to determine equality. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Number + * @param {*} target The item to find. + * @param {Array} xs The array to search in. + * @return {Number} the index of the target, or -1 if the target is not found. + * @see R.indexOf + * @example + * + * R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6 + * R.lastIndexOf(10, [1,2,3,4]); //=> -1 + */ + var lastIndexOf = _curry2(function lastIndexOf(target, xs) { + if (_hasMethod('lastIndexOf', xs)) { + return xs.lastIndexOf(target); + } else { + var idx = xs.length - 1; + while (idx >= 0) { + if (equals(xs[idx], target)) { + return idx; + } + idx -= 1; + } + return -1; + } + }); + + /** + * Returns a new list, constructed by applying the supplied function to every element of the + * supplied list. + * + * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the + * native `Array.prototype.map` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [b] + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {Array} list The list to be iterated over. + * @return {Array} The new list. + * @example + * + * var double = function(x) { + * return x * 2; + * }; + * + * R.map(double, [1, 2, 3]); //=> [2, 4, 6] + */ + var map = _curry2(_dispatchable('map', _xmap, _map)); + + /** + * Map, but for objects. Creates an object with the same keys as `obj` and values + * generated by running each property of `obj` through `fn`. `fn` is passed one argument: + * *(value)*. + * + * @func + * @memberOf R + * @category Object + * @sig (v -> v) -> {k: v} -> {k: v} + * @param {Function} fn A function called for each property in `obj`. Its return value will + * become a new property on the return object. + * @param {Object} obj The object to iterate over. + * @return {Object} A new object with the same keys as `obj` and values that are the result + * of running each property through `fn`. + * @example + * + * var values = { x: 1, y: 2, z: 3 }; + * var double = function(num) { + * return num * 2; + * }; + * + * R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 } + */ + var mapObj = _curry2(function mapObj(fn, obj) { + return _reduce(function (acc, key) { + acc[key] = fn(obj[key]); + return acc; + }, {}, keys(obj)); + }); + + /** + * Like `mapObj`, but but passes additional arguments to the predicate function. The + * predicate function is passed three arguments: *(value, key, obj)*. + * + * @func + * @memberOf R + * @category Object + * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v} + * @param {Function} fn A function called for each property in `obj`. Its return value will + * become a new property on the return object. + * @param {Object} obj The object to iterate over. + * @return {Object} A new object with the same keys as `obj` and values that are the result + * of running each property through `fn`. + * @example + * + * var values = { x: 1, y: 2, z: 3 }; + * var prependKeyAndDouble = function(num, key, obj) { + * return key + (num * 2); + * }; + * + * R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' } + */ + var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) { + return _reduce(function (acc, key) { + acc[key] = fn(obj[key], key, obj); + return acc; + }, {}, keys(obj)); + }); + + /** + * Returns `true` if no elements of the list match the predicate, + * `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise. + * @see R.all, R.any + * @example + * + * R.none(R.isNaN, [1, 2, 3]); //=> true + * R.none(R.isNaN, [1, 2, 3, NaN]); //=> false + */ + var none = _curry2(_complement(_dispatchable('any', _xany, any))); + + /** + * A function that returns the first truthy of two arguments otherwise the + * last argument. Note that this is NOT short-circuited, meaning that if + * expressions are passed they are both evaluated. + * + * Dispatches to the `or` method of the first argument if applicable. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> * -> * + * @param {*} a any value + * @param {*} b any other value + * @return {*} the first truthy argument, otherwise the last argument. + * @see R.either + * @example + * + * R.or(false, true); //=> true + * R.or(0, []); //=> [] + * R.or(null, ''); => '' + */ + var or = _curry2(function or(a, b) { + return _hasMethod('or', a) ? a.or(b) : a || b; + }); + + /** + * Accepts as its arguments a function and any number of values and returns a function that, + * when invoked, calls the original function with all of the values prepended to the + * original function's arguments list. In some libraries this function is named `applyLeft`. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n) + * @param {Function} fn The function to invoke. + * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked. + * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` + * with `args` prepended to `fn`'s arguments list. + * @example + * + * var multiply = function(a, b) { return a * b; }; + * var double = R.partial(multiply, 2); + * double(2); //=> 4 + * + * var greet = function(salutation, title, firstName, lastName) { + * return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; + * }; + * var sayHello = R.partial(greet, 'Hello'); + * var sayHelloToMs = R.partial(sayHello, 'Ms.'); + * sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!' + */ + var partial = curry(_createPartialApplicator(_concat)); + + /** + * Accepts as its arguments a function and any number of values and returns a function that, + * when invoked, calls the original function with all of the values appended to the original + * function's arguments list. + * + * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments + * from the right to the left. In some libraries this function is named `applyRight`. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i) + * @param {Function} fn The function to invoke. + * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked. + * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with + * `args` appended to `fn`'s arguments list. + * @example + * + * var greet = function(salutation, title, firstName, lastName) { + * return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; + * }; + * var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones'); + * + * greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!' + */ + var partialRight = curry(_createPartialApplicator(flip(_concat))); + + /** + * Takes a predicate and a list and returns the pair of lists of + * elements which do and do not satisfy the predicate, respectively. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [[a],[a]] + * @param {Function} pred A predicate to determine which array the element belongs to. + * @param {Array} list The array to partition. + * @return {Array} A nested array, containing first an array of elements that satisfied the predicate, + * and second an array of elements that did not satisfy. + * @example + * + * R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']); + * //=> [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ] + */ + var partition = _curry2(function partition(pred, list) { + return _reduce(function (acc, elt) { + var xs = acc[pred(elt) ? 0 : 1]; + xs[xs.length] = elt; + return acc; + }, [ + [], + [] + ], list); + }); + + /** + * Determines whether a nested path on an object has a specific value, + * in `R.equals` terms. Most likely used to filter a list. + * + * @func + * @memberOf R + * @category Relation + * @sig [String] -> * -> {String: *} -> Boolean + * @param {Array} path The path of the nested property to use + * @param {*} val The value to compare the nested property with + * @param {Object} obj The object to check the nested property in + * @return {Boolean} `true` if the value equals the nested object property, + * `false` otherwise. + * @example + * + * var user1 = { address: { zipCode: 90210 } }; + * var user2 = { address: { zipCode: 55555 } }; + * var user3 = { name: 'Bob' }; + * var users = [ user1, user2, user3 ]; + * var isFamous = R.pathEq(['address', 'zipCode'], 90210); + * R.filter(isFamous, users); //=> [ user1 ] + */ + var pathEq = _curry3(function pathEq(_path, val, obj) { + return equals(path(_path, obj), val); + }); + + /** + * Returns a new list by plucking the same named property off all objects in the list supplied. + * + * @func + * @memberOf R + * @category List + * @sig k -> [{k: v}] -> [v] + * @param {Number|String} key The key name to pluck off of each object. + * @param {Array} list The array to consider. + * @return {Array} The list of values for the given key. + * @example + * + * R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2] + * R.pluck(0)([[1, 2], [3, 4]]); //=> [1, 3] + */ + var pluck = _curry2(function pluck(p, list) { + return map(prop(p), list); + }); + + /** + * Returns `true` if the specified object property is equal, in `R.equals` + * terms, to the given value; `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig String -> a -> Object -> Boolean + * @param {String} name + * @param {*} val + * @param {*} obj + * @return {Boolean} + * @see R.equals, R.propSatisfies + * @example + * + * var abby = {name: 'Abby', age: 7, hair: 'blond'}; + * var fred = {name: 'Fred', age: 12, hair: 'brown'}; + * var rusty = {name: 'Rusty', age: 10, hair: 'brown'}; + * var alois = {name: 'Alois', age: 15, disposition: 'surly'}; + * var kids = [abby, fred, rusty, alois]; + * var hasBrownHair = R.propEq('hair', 'brown'); + * R.filter(hasBrownHair, kids); //=> [fred, rusty] + */ + var propEq = _curry3(function propEq(name, val, obj) { + return propSatisfies(equals(val), name, obj); + }); + + /** + * Returns `true` if the specified object property is of the given type; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Type + * @sig Type -> String -> Object -> Boolean + * @param {Function} type + * @param {String} name + * @param {*} obj + * @return {Boolean} + * @see R.is + * @see R.propSatisfies + * @example + * + * R.propIs(Number, 'x', {x: 1, y: 2}); //=> true + * R.propIs(Number, 'x', {x: 'foo'}); //=> false + * R.propIs(Number, 'x', {}); //=> false + */ + var propIs = _curry3(function propIs(type, name, obj) { + return propSatisfies(is(type), name, obj); + }); + + /** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It may use `R.reduced` to + * shortcut the iteration. + * + * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description + * @see R.reduced + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3]; + * var add = function(a, b) { + * return a + b; + * }; + * + * R.reduce(add, 10, numbers); //=> 16 + */ + var reduce = _curry3(_reduce); + + /** + * Similar to `filter`, except that it keeps only values for which the given predicate + * function returns falsy. The predicate function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.filter + * @example + * + * var isOdd = function(n) { + * return n % 2 === 1; + * }; + * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4] + */ + var reject = _curry2(function reject(fn, list) { + return filter(_complement(fn), list); + }); + + /** + * Returns a fixed list of size `n` containing a specified identical value. + * + * @func + * @memberOf R + * @category List + * @sig a -> n -> [a] + * @param {*} value The value to repeat. + * @param {Number} n The desired size of the output list. + * @return {Array} A new array containing `n` `value`s. + * @example + * + * R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi'] + * + * var obj = {}; + * var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}] + * repeatedObjs[0] === repeatedObjs[1]; //=> true + */ + var repeat = _curry2(function repeat(value, n) { + return times(always(value), n); + }); + + /** + * Returns the elements of the given list or string (or object with a `slice` + * method) from `fromIndex` (inclusive) to `toIndex` (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @sig Number -> Number -> String -> String + * @param {Number} fromIndex The start index (inclusive). + * @param {Number} toIndex The end index (exclusive). + * @param {*} list + * @return {*} + * @example + * + * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] + * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] + * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(0, 3, 'ramda'); //=> 'ram' + */ + var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) { + return Array.prototype.slice.call(list, fromIndex, toIndex); + })); + + /** + * Splits a collection into slices of the specified length. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [[a]] + * @sig Number -> String -> [String] + * @param {Number} n + * @param {Array} list + * @return {Array} + * @example + * + * R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]] + * R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz'] + */ + var splitEvery = _curry2(function splitEvery(n, list) { + if (n <= 0) { + throw new Error('First argument to splitEvery must be a positive integer'); + } + var result = []; + var idx = 0; + while (idx < list.length) { + result.push(slice(idx, idx += n, list)); + } + return result; + }); + + /** + * Adds together all the elements of a list. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list An array of numbers + * @return {Number} The sum of all the numbers in the list. + * @see R.reduce + * @example + * + * R.sum([2,4,6,8,100,1]); //=> 121 + */ + var sum = reduce(add, 0); + + /** + * Returns all but the first element of the given list or string (or object + * with a `tail` method). + * + * @func + * @memberOf R + * @category List + * @see R.head, R.init, R.last + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.tail([1, 2, 3]); //=> [2, 3] + * R.tail([1, 2]); //=> [2] + * R.tail([1]); //=> [] + * R.tail([]); //=> [] + * + * R.tail('abc'); //=> 'bc' + * R.tail('ab'); //=> 'b' + * R.tail('a'); //=> '' + * R.tail(''); //=> '' + */ + var tail = _checkForMethod('tail', slice(1, Infinity)); + + /** + * Returns the first `n` elements of the given list, string, or + * transducer/transformer (or object with a `take` method). + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n + * @param {*} list + * @return {*} + * @see R.drop + * @example + * + * R.take(1, ['foo', 'bar', 'baz']); //=> ['foo'] + * R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] + * R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.take(3, 'ramda'); //=> 'ram' + * + * var personnel = [ + * 'Dave Brubeck', + * 'Paul Desmond', + * 'Eugene Wright', + * 'Joe Morello', + * 'Gerry Mulligan', + * 'Bob Bates', + * 'Joe Dodge', + * 'Ron Crotty' + * ]; + * + * var takeFive = R.take(5); + * takeFive(personnel); + * //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan'] + */ + var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) { + return slice(0, n < 0 ? Infinity : n, xs); + })); + + /** + * Returns a new list containing the first `n` elements of a given list, passing each value + * to the supplied predicate function, and terminating when the predicate function returns + * `false`. Excludes the element that caused the predicate function to fail. The predicate + * function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.dropWhile + * @example + * + * var isNotFour = function(x) { + * return !(x === 4); + * }; + * + * R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3] + */ + var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) { + var idx = 0, len = list.length; + while (idx < len && fn(list[idx])) { + idx += 1; + } + return _slice(list, 0, idx); + })); + + /** + * Initializes a transducer using supplied iterator function. Returns a single item by + * iterating through the list, successively calling the transformed iterator function and + * passing it an accumulator value and the current value from the array, and then passing + * the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It will be wrapped as a + * transformer to initialize the transducer. A transformer can be passed directly in place + * of an iterator function. In both cases, iteration may be stopped early with the + * `R.reduced` function. + * + * A transducer is a function that accepts a transformer and returns a transformer and can + * be composed directly. + * + * A transformer is an an object that provides a 2-arity reducing iterator function, step, + * 0-arity initial value function, init, and 1-arity result extraction function, result. + * The step function is used as the iterator function in reduce. The result function is used + * to convert the final accumulator into the return type and in most cases is R.identity. + * The init function can be used to provide an initial accumulator, but is ignored by transduce. + * + * The iteration is performed with R.reduce after initializing the transducer. + * + * @func + * @memberOf R + * @category List + * @see R.reduce, R.reduced, R.into + * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a + * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. Wrapped as transformer, if necessary, and used to + * initialize the transducer + * @param {*} acc The initial accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var transducer = R.compose(R.map(R.add(1)), R.take(2)); + * + * R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3] + */ + var transduce = curryN(4, function transduce(xf, fn, acc, list) { + return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list); + }); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list. Duplication is + * determined according to the value returned by applying the supplied predicate to two list elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @return {Array} The first and second lists concatenated, with + * duplicates removed. + * @see R.union + * @example + * + * function cmp(x, y) { return x.a === y.a; } + * var l1 = [{a: 1}, {a: 2}]; + * var l2 = [{a: 1}, {a: 4}]; + * R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}] + */ + var unionWith = _curry3(function unionWith(pred, list1, list2) { + return uniqWith(pred, _concat(list1, list2)); + }); + + /** + * Returns a new list containing only one copy of each element in the original list. + * `R.equals` is used to determine equality. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * R.uniq([1, 1, 2, 1]); //=> [1, 2] + * R.uniq([1, '1']); //=> [1, '1'] + * R.uniq([[42], [42]]); //=> [[42]] + */ + var uniq = uniqWith(equals); + + /** + * Returns a new list by pulling every item at the first level of nesting out, and putting + * them in a new array. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] + * @param {Array} list The array to consider. + * @return {Array} The flattened list. + * @see R.flatten + * @example + * + * R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]] + * R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6] + */ + var unnest = _curry1(_makeFlat(false)); + + /** + * Accepts a function `fn` and any number of transformer functions and returns a new + * function. When the new function is invoked, it calls the function `fn` with parameters + * consisting of the result of calling each supplied handler on successive arguments to the + * new function. + * + * If more arguments are passed to the returned function than transformer functions, those + * arguments are passed directly to `fn` as additional parameters. If you expect additional + * arguments that don't need to be transformed, although you can ignore them, it's best to + * pass an identity function so that the new function reports the correct arity. + * + * @func + * @memberOf R + * @category Function + * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z) + * @param {Function} fn The function to wrap. + * @param {...Function} transformers A variable number of transformer functions + * @return {Function} The wrapped function. + * @example + * + * var double = function(y) { return y * 2; }; + * var square = function(x) { return x * x; }; + * var add = function(a, b) { return a + b; }; + * // Adds any number of arguments together + * var addAll = function() { + * return R.reduce(add, 0, arguments); + * }; + * + * // Basic example + * var addDoubleAndSquare = R.useWith(addAll, double, square); + * + * //≅ addAll(double(10), square(5)); + * addDoubleAndSquare(10, 5); //=> 45 + * + * // Example of passing more arguments than transformers + * //≅ addAll(double(10), square(5), 100); + * addDoubleAndSquare(10, 5, 100); //=> 145 + * + * // If there are extra _expected_ arguments that don't need to be transformed, although + * // you can ignore them, it might be best to pass in the identity function so that the new + * // function correctly reports arity. + * var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity); + * // addDoubleAndSquareWithExtraParams.length //=> 3 + * //≅ addAll(double(10), square(5), R.identity(100)); + * addDoubleAndSquare(10, 5, 100); //=> 145 + */ + /*, transformers */ + var useWith = curry(function useWith(fn) { + var transformers = _slice(arguments, 1); + var tlen = transformers.length; + return curry(_arity(tlen, function () { + var args = [], idx = 0; + while (idx < tlen) { + args[idx] = transformers[idx](arguments[idx]); + idx += 1; + } + return fn.apply(this, args.concat(_slice(arguments, tlen))); + })); + }); + + /** + * Takes a spec object and a test object; returns true if the test satisfies + * the spec, false otherwise. An object satisfies the spec if, for each of the + * spec's own properties, accessing that property of the object gives the same + * value (in `R.equals` terms) as accessing that property of the spec. + * + * `whereEq` is a specialization of [`where`](#where). + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> {String: *} -> Boolean + * @param {Object} spec + * @param {Object} testObj + * @return {Boolean} + * @see R.where + * @example + * + * // pred :: Object -> Boolean + * var pred = R.whereEq({a: 1, b: 2}); + * + * pred({a: 1}); //=> false + * pred({a: 1, b: 2}); //=> true + * pred({a: 1, b: 2, c: 3}); //=> true + * pred({a: 1, b: 1}); //=> false + */ + var whereEq = _curry2(function whereEq(spec, testObj) { + return where(mapObj(equals, spec), testObj); + }); + + var _flatCat = function () { + var preservingReduced = function (xf) { + return { + '@@transducer/init': _xfBase.init, + '@@transducer/result': function (result) { + return xf['@@transducer/result'](result); + }, + '@@transducer/step': function (result, input) { + var ret = xf['@@transducer/step'](result, input); + return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret; + } + }; + }; + return function _xcat(xf) { + var rxf = preservingReduced(xf); + return { + '@@transducer/init': _xfBase.init, + '@@transducer/result': function (result) { + return rxf['@@transducer/result'](result); + }, + '@@transducer/step': function (result, input) { + return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input); + } + }; + }; + }(); + + var _indexOf = function _indexOf(list, item, from) { + var idx = from; + while (idx < list.length) { + if (equals(list[idx], item)) { + return idx; + } + idx += 1; + } + return -1; + }; + + /** + * Create a predicate wrapper which will call a pick function (all/any) for each predicate + * + * @private + * @see R.all + * @see R.any + */ + // Call function immediately if given arguments + // Return a function which will call the predicates with the provided arguments + var _predicateWrap = function _predicateWrap(predPicker) { + return function (preds) { + var predIterator = function () { + var args = arguments; + return predPicker(function (predicate) { + return predicate.apply(null, args); + }, preds); + }; + return arguments.length > 1 ? // Call function immediately if given arguments + predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments + _arity(Math.max.apply(Math, pluck('length', preds)), predIterator); + }; + }; + + var _xchain = _curry2(function _xchain(f, xf) { + return map(f, _flatCat(xf)); + }); + + /** + * Given a list of predicates, returns a new predicate that will be true exactly when all of them are. + * + * @func + * @memberOf R + * @category Logic + * @sig [(*... -> Boolean)] -> (*... -> Boolean) + * @param {Array} list An array of predicate functions + * @param {*} optional Any arguments to pass into the predicates + * @return {Function} a function that applies its arguments to each of + * the predicates, returning `true` if all are satisfied. + * @see R.anyPass + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0}; + * var f = R.allPass([gt10, even]); + * f(11); //=> false + * f(12); //=> true + */ + var allPass = _curry1(_predicateWrap(all)); + + /** + * Given a list of predicates returns a new predicate that will be true exactly when any one of them is. + * + * @func + * @memberOf R + * @category Logic + * @sig [(*... -> Boolean)] -> (*... -> Boolean) + * @param {Array} list An array of predicate functions + * @param {*} optional Any arguments to pass into the predicates + * @return {Function} A function that applies its arguments to each of the predicates, returning + * `true` if all are satisfied. + * @see R.allPass + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0}; + * var f = R.anyPass([gt10, even]); + * f(11); //=> true + * f(8); //=> true + * f(9); //=> false + */ + var anyPass = _curry1(_predicateWrap(any)); + + /** + * ap applies a list of functions to a list of values. + * + * @func + * @memberOf R + * @category Function + * @sig [f] -> [a] -> [f a] + * @param {Array} fns An array of functions + * @param {Array} vs An array of values + * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn. + * @example + * + * R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6] + */ + var ap = _curry2(function ap(fns, vs) { + return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) { + return _concat(acc, map(fn, vs)); + }, [], fns); + }); + + /** + * Returns the result of calling its first argument with the remaining + * arguments. This is occasionally useful as a converging function for + * `R.converge`: the left branch can produce a function while the right + * branch produces a value to be passed to that function as an argument. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a),*... -> a + * @param {Function} fn The function to apply to the remaining arguments. + * @param {...*} args Any number of positional arguments. + * @return {*} + * @see R.apply + * @example + * + * var indentN = R.pipe(R.times(R.always(' ')), + * R.join(''), + * R.replace(/^(?!$)/gm)); + * + * var format = R.converge(R.call, + * R.pipe(R.prop('indent'), indentN), + * R.prop('value')); + * + * format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n' + */ + var call = curry(function call(fn) { + return fn.apply(this, _slice(arguments, 1)); + }); + + /** + * `chain` maps a function over a list and concatenates the results. + * This implementation is compatible with the + * Fantasy-land Chain spec, and will work with types that implement that spec. + * `chain` is also known as `flatMap` in some libraries + * + * @func + * @memberOf R + * @category List + * @sig (a -> [b]) -> [a] -> [b] + * @param {Function} fn + * @param {Array} list + * @return {Array} + * @example + * + * var duplicate = function(n) { + * return [n, n]; + * }; + * R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3] + */ + var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) { + return unnest(map(fn, list)); + })); + + /** + * Turns a list of Functors into a Functor of a list, applying + * a mapping function to the elements of the list along the way. + * + * @func + * @memberOf R + * @category List + * @see R.commute + * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b] + * @param {Function} fn The transformation function + * @param {Function} of A function that returns the data type to return + * @param {Array} list An array of functors of the same type + * @return {*} + * @example + * + * R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]); //=> [[11, 12], [11, 13]] + * R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]); //=> [[11, 13], [12, 13]] + * R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]] + * R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([11, 12, 13]) + * R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() + */ + var commuteMap = _curry3(function commuteMap(fn, of, list) { + function consF(acc, ftor) { + return ap(map(append, fn(ftor)), acc); + } + return _reduce(consF, of([]), list); + }); + + /** + * Wraps a constructor function inside a curried function that can be called with the same + * arguments and returns the same type. The arity of the function returned is specified + * to allow using variadic constructor functions. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> {*}) -> (* -> {*}) + * @param {Number} n The arity of the constructor function. + * @param {Function} Fn The constructor function to wrap. + * @return {Function} A wrapped, curried constructor function. + * @example + * + * // Variadic constructor function + * var Widget = function() { + * this.children = Array.prototype.slice.call(arguments); + * // ... + * }; + * Widget.prototype = { + * // ... + * }; + * var allConfigs = [ + * // ... + * ]; + * R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets + */ + var constructN = _curry2(function constructN(n, Fn) { + if (n > 10) { + throw new Error('Constructor with greater than ten arguments'); + } + if (n === 0) { + return function () { + return new Fn(); + }; + } + return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) { + switch (arguments.length) { + case 1: + return new Fn($0); + case 2: + return new Fn($0, $1); + case 3: + return new Fn($0, $1, $2); + case 4: + return new Fn($0, $1, $2, $3); + case 5: + return new Fn($0, $1, $2, $3, $4); + case 6: + return new Fn($0, $1, $2, $3, $4, $5); + case 7: + return new Fn($0, $1, $2, $3, $4, $5, $6); + case 8: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7); + case 9: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8); + case 10: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9); + } + })); + }); + + /** + * Accepts at least three functions and returns a new function. When invoked, this new + * function will invoke the first function, `after`, passing as its arguments the + * results of invoking the subsequent functions with whatever arguments are passed to + * the new function. + * + * @func + * @memberOf R + * @category Function + * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z) + * @param {Function} after A function. `after` will be invoked with the return values of + * `fn1` and `fn2` as its arguments. + * @param {...Function} functions A variable number of functions. + * @return {Function} A new function. + * @example + * + * var add = function(a, b) { return a + b; }; + * var multiply = function(a, b) { return a * b; }; + * var subtract = function(a, b) { return a - b; }; + * + * //≅ multiply( add(1, 2), subtract(1, 2) ); + * R.converge(multiply, add, subtract)(1, 2); //=> -3 + * + * var add3 = function(a, b, c) { return a + b + c; }; + * R.converge(add3, multiply, add, subtract)(1, 2); //=> 4 + */ + var converge = curryN(3, function converge(after) { + var fns = _slice(arguments, 1); + return curryN(Math.max.apply(Math, pluck('length', fns)), function () { + var args = arguments; + var context = this; + return after.apply(context, _map(function (fn) { + return fn.apply(context, args); + }, fns)); + }); + }); + + /** + * Returns all but the first `n` elements of the given list, string, or + * transducer/transformer (or object with a `drop` method). + * + * @func + * @memberOf R + * @category List + * @see R.transduce + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n + * @param {*} list + * @return {*} + * @see R.take + * @example + * + * R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] + * R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz'] + * R.drop(3, ['foo', 'bar', 'baz']); //=> [] + * R.drop(4, ['foo', 'bar', 'baz']); //=> [] + * R.drop(3, 'ramda'); //=> 'da' + */ + var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) { + return slice(Math.max(0, n), Infinity, xs); + })); + + /** + * Returns a list containing all but the last `n` elements of the given `list`. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n The number of elements of `xs` to skip. + * @param {Array} xs The collection to consider. + * @return {Array} + * @see R.takeLast + * @example + * + * R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] + * R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo'] + * R.dropLast(3, ['foo', 'bar', 'baz']); //=> [] + * R.dropLast(4, ['foo', 'bar', 'baz']); //=> [] + * R.dropLast(3, 'ramda'); //=> 'ra' + */ + var dropLast = _curry2(function dropLast(n, xs) { + return take(n < xs.length ? xs.length - n : 0, xs); + }); + + /** + * Returns a new list without any consecutively repeating elements. Equality is + * determined by applying the supplied predicate two consecutive elements. + * The first element in a series of equal element is the one being preserved. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list The array to consider. + * @return {Array} `list` without repeating elements. + * @example + * + * function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); }; + * var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]; + * R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3] + */ + var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) { + var result = []; + var idx = 1; + var len = list.length; + if (len !== 0) { + result[0] = list[0]; + while (idx < len) { + if (!pred(last(result), list[idx])) { + result[result.length] = list[idx]; + } + idx += 1; + } + } + return result; + })); + + /** + * Reports whether two objects have the same value, in `R.equals` terms, + * for the specified property. Useful as a curried predicate. + * + * @func + * @memberOf R + * @category Object + * @sig k -> {k: v} -> {k: v} -> Boolean + * @param {String} prop The name of the property to compare + * @param {Object} obj1 + * @param {Object} obj2 + * @return {Boolean} + * + * @example + * + * var o1 = { a: 1, b: 2, c: 3, d: 4 }; + * var o2 = { a: 10, b: 20, c: 3, d: 40 }; + * R.eqProps('a', o1, o2); //=> false + * R.eqProps('c', o1, o2); //=> true + */ + var eqProps = _curry3(function eqProps(prop, obj1, obj2) { + return equals(obj1[prop], obj2[prop]); + }); + + /** + * Returns the position of the first occurrence of an item in an array, + * or -1 if the item is not included in the array. `R.equals` is used to + * determine equality. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Number + * @param {*} target The item to find. + * @param {Array} xs The array to search in. + * @return {Number} the index of the target, or -1 if the target is not found. + * @see R.lastIndexOf + * @example + * + * R.indexOf(3, [1,2,3,4]); //=> 2 + * R.indexOf(10, [1,2,3,4]); //=> -1 + */ + var indexOf = _curry2(function indexOf(target, xs) { + return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0); + }); + + /** + * Returns all but the last element of the given list or string. + * + * @func + * @memberOf R + * @category List + * @see R.last, R.head, R.tail + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.init([1, 2, 3]); //=> [1, 2] + * R.init([1, 2]); //=> [1] + * R.init([1]); //=> [] + * R.init([]); //=> [] + * + * R.init('abc'); //=> 'ab' + * R.init('ab'); //=> 'a' + * R.init('a'); //=> '' + * R.init(''); //=> '' + */ + var init = slice(0, -1); + + /** + * Returns `true` if all elements are unique, in `R.equals` terms, + * otherwise `false`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> Boolean + * @param {Array} list The array to consider. + * @return {Boolean} `true` if all elements are unique, else `false`. + * @example + * + * R.isSet(['1', 1]); //=> true + * R.isSet([1, 1]); //=> false + * R.isSet([[42], [42]]); //=> false + */ + var isSet = _curry1(function isSet(list) { + var len = list.length; + var idx = 0; + while (idx < len) { + if (_indexOf(list, list[idx], idx + 1) >= 0) { + return false; + } + idx += 1; + } + return true; + }); + + /** + * Returns a lens for the given getter and setter functions. The getter "gets" + * the value of the focus; the setter "sets" the value of the focus. The setter + * should not mutate the data structure. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig (s -> a) -> ((a, s) -> s) -> Lens s a + * @param {Function} getter + * @param {Function} setter + * @return {Lens} + * @see R.view, R.set, R.over, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lens(R.prop('x'), R.assoc('x')); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} + */ + var lens = _curry2(function lens(getter, setter) { + return function (f) { + return function (s) { + return map(function (v) { + return setter(v, s); + }, f(getter(s))); + }; + }; + }); + + /** + * Returns a lens whose focus is the specified index. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Number -> Lens s a + * @param {Number} n + * @return {Lens} + * @see R.view, R.set, R.over + * @example + * + * var headLens = R.lensIndex(0); + * + * R.view(headLens, ['a', 'b', 'c']); //=> 'a' + * R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c'] + * R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c'] + */ + var lensIndex = _curry1(function lensIndex(n) { + return lens(nth(n), update(n)); + }); + + /** + * Returns a lens whose focus is the specified property. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig String -> Lens s a + * @param {String} k + * @return {Lens} + * @see R.view, R.set, R.over + * @example + * + * var xLens = R.lensProp('x'); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} + */ + var lensProp = _curry1(function lensProp(k) { + return lens(prop(k), assoc(k)); + }); + + /** + * "lifts" a function to be the specified arity, so that it may "map over" that many + * lists (or other Functors). + * + * @func + * @memberOf R + * @see R.lift + * @category Function + * @sig Number -> (*... -> *) -> ([*]... -> [*]) + * @param {Function} fn The function to lift into higher context + * @return {Function} The function `fn` applicable to mappable objects. + * @example + * + * var madd3 = R.liftN(3, R.curryN(3, function() { + * return R.reduce(R.add, 0, arguments); + * })); + * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] + */ + var liftN = _curry2(function liftN(arity, fn) { + var lifted = curryN(arity, fn); + return curryN(arity, function () { + return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1)); + }); + }); + + /** + * Returns the mean of the given list of numbers. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list + * @return {Number} + * @example + * + * R.mean([2, 7, 9]); //=> 6 + * R.mean([]); //=> NaN + */ + var mean = _curry1(function mean(list) { + return sum(list) / list.length; + }); + + /** + * Returns the median of the given list of numbers. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list + * @return {Number} + * @example + * + * R.median([2, 9, 7]); //=> 7 + * R.median([7, 2, 10, 9]); //=> 8 + * R.median([]); //=> NaN + */ + var median = _curry1(function median(list) { + var len = list.length; + if (len === 0) { + return NaN; + } + var width = 2 - len % 2; + var idx = (len - width) / 2; + return mean(_slice(list).sort(function (a, b) { + return a < b ? -1 : a > b ? 1 : 0; + }).slice(idx, idx + width)); + }); + + /** + * Merges a list of objects together into one object. + * + * @func + * @memberOf R + * @category List + * @sig [{k: v}] -> {k: v} + * @param {Array} list An array of objects + * @return {Object} A merged object. + * @see R.reduce + * @example + * + * R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3} + * R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2} + */ + var mergeAll = _curry1(function mergeAll(list) { + return reduce(merge, {}, list); + }); + + /** + * Performs left-to-right function composition. The leftmost function may have + * any arity; the remaining functions must be unary. + * + * In some libraries this function is named `sequence`. + * + * @func + * @memberOf R + * @category Function + * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.compose + * @example + * + * var f = R.pipe(Math.pow, R.negate, R.inc); + * + * f(3, 4); // -(3^4) + 1 + */ + var pipe = function pipe() { + if (arguments.length === 0) { + throw new Error('pipe requires at least one argument'); + } + return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments))); + }; + + /** + * Performs left-to-right composition of one or more Promise-returning + * functions. The leftmost function may have any arity; the remaining + * functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z) + * @param {...Function} functions + * @return {Function} + * @see R.composeP + * @example + * + * // followersForUser :: String -> Promise [User] + * var followersForUser = R.pipeP(db.getUserById, db.getFollowers); + */ + var pipeP = function pipeP() { + if (arguments.length === 0) { + throw new Error('pipeP requires at least one argument'); + } + return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments))); + }; + + /** + * Multiplies together all the elements of a list. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list An array of numbers + * @return {Number} The product of all the numbers in the list. + * @see R.reduce + * @example + * + * R.product([2,4,6,8,100,1]); //=> 38400 + */ + var product = reduce(multiply, 1); + + /** + * Reasonable analog to SQL `select` statement. + * + * @func + * @memberOf R + * @category Object + * @category Relation + * @sig [k] -> [{k: v}] -> [{k: v}] + * @param {Array} props The property names to project + * @param {Array} objs The objects to query + * @return {Array} An array of objects with just the `props` properties. + * @example + * + * var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2}; + * var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7}; + * var kids = [abby, fred]; + * R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}] + */ + // passing `identity` gives correct arity + var project = useWith(_map, pickAll, identity); + + /** + * Returns a new list containing the last `n` elements of the given list. + * If `n > list.length`, returns a list of `list.length` elements. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n The number of elements to return. + * @param {Array} xs The collection to consider. + * @return {Array} + * @see R.dropLast + * @example + * + * R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz'] + * R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz'] + * R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.takeLast(3, 'ramda'); //=> 'mda' + */ + var takeLast = _curry2(function takeLast(n, xs) { + return drop(n >= 0 ? xs.length - n : 0, xs); + }); + + var _contains = function _contains(a, list) { + return _indexOf(list, a, 0) >= 0; + }; + + // mapPairs :: (Object, [String]) -> [String] + // Function, RegExp, user-defined types + var _toString = function _toString(x, seen) { + var recur = function recur(y) { + var xs = seen.concat([x]); + return _contains(y, xs) ? '' : _toString(y, xs); + }; + // mapPairs :: (Object, [String]) -> [String] + var mapPairs = function (obj, keys) { + return _map(function (k) { + return _quote(k) + ': ' + recur(obj[k]); + }, keys.slice().sort()); + }; + switch (Object.prototype.toString.call(x)) { + case '[object Arguments]': + return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))'; + case '[object Array]': + return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\d+$/), keys(x)))).join(', ') + ']'; + case '[object Boolean]': + return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString(); + case '[object Date]': + return 'new Date(' + _quote(_toISOString(x)) + ')'; + case '[object Null]': + return 'null'; + case '[object Number]': + return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10); + case '[object String]': + return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x); + case '[object Undefined]': + return 'undefined'; + default: + return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types + '{' + mapPairs(x, keys(x)).join(', ') + '}'; + } + }; + + /** + * Turns a list of Functors into a Functor of a list. + * + * @func + * @memberOf R + * @category List + * @see R.commuteMap + * @sig Functor f => (x -> f x) -> [f a] -> f [a] + * @param {Function} of A function that returns the data type to return + * @param {Array} list An array of functors of the same type + * @return {*} + * @example + * + * R.commute(R.of, [[1], [2, 3]]); //=> [[1, 2], [1, 3]] + * R.commute(R.of, [[1, 2], [3]]); //=> [[1, 3], [2, 3]] + * R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]] + * R.commute(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3]) + * R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() + */ + var commute = commuteMap(identity); + + /** + * Performs right-to-left function composition. The rightmost function may have + * any arity; the remaining functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.pipe + * @example + * + * var f = R.compose(R.inc, R.negate, Math.pow); + * + * f(3, 4); // -(3^4) + 1 + */ + var compose = function compose() { + if (arguments.length === 0) { + throw new Error('compose requires at least one argument'); + } + return pipe.apply(this, reverse(arguments)); + }; + + /** + * Returns the right-to-left Kleisli composition of the provided functions, + * each of which must return a value of a type supported by [`chain`](#chain). + * + * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`. + * + * @func + * @memberOf R + * @category Function + * @see R.pipeK + * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z) + * @param {...Function} + * @return {Function} + * @example + * + * // parseJson :: String -> Maybe * + * // get :: String -> Object -> Maybe * + * + * // getStateCode :: Maybe String -> Maybe String + * var getStateCode = R.composeK( + * R.compose(Maybe.of, R.toUpper), + * get('state'), + * get('address'), + * get('user'), + * parseJson + * ); + * + * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}')); + * //=> Just('NY') + * getStateCode(Maybe.of('[Invalid JSON]')); + * //=> Nothing() + */ + var composeK = function composeK() { + return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments)); + }; + + /** + * Performs right-to-left composition of one or more Promise-returning + * functions. The rightmost function may have any arity; the remaining + * functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z) + * @param {...Function} functions + * @return {Function} + * @see R.pipeP + * @example + * + * // followersForUser :: String -> Promise [User] + * var followersForUser = R.composeP(db.getFollowers, db.getUserById); + */ + var composeP = function composeP() { + if (arguments.length === 0) { + throw new Error('composeP requires at least one argument'); + } + return pipeP.apply(this, reverse(arguments)); + }; + + /** + * Wraps a constructor function inside a curried function that can be called with the same + * arguments and returns the same type. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> {*}) -> (* -> {*}) + * @param {Function} Fn The constructor function to wrap. + * @return {Function} A wrapped, curried constructor function. + * @example + * + * // Constructor function + * var Widget = function(config) { + * // ... + * }; + * Widget.prototype = { + * // ... + * }; + * var allConfigs = [ + * // ... + * ]; + * R.map(R.construct(Widget), allConfigs); // a list of Widgets + */ + var construct = _curry1(function construct(Fn) { + return constructN(Fn.length, Fn); + }); + + /** + * Returns `true` if the specified value is equal, in `R.equals` terms, + * to at least one element of the given list; `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Boolean + * @param {Object} a The item to compare against. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the item is in the list, `false` otherwise. + * + * @example + * + * R.contains(3, [1, 2, 3]); //=> true + * R.contains(4, [1, 2, 3]); //=> false + * R.contains([42], [[42]]); //=> true + */ + var contains = _curry2(_contains); + + /** + * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @return {Array} The elements in `list1` that are not in `list2`. + * @see R.differenceWith + * @example + * + * R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2] + * R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5] + */ + var difference = _curry2(function difference(first, second) { + var out = []; + var idx = 0; + var firstLen = first.length; + while (idx < firstLen) { + if (!_contains(first[idx], second) && !_contains(first[idx], out)) { + out[out.length] = first[idx]; + } + idx += 1; + } + return out; + }); + + /** + * Returns a new list without any consecutively repeating elements. + * `R.equals` is used to determine equality. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The array to consider. + * @return {Array} `list` without repeating elements. + * @example + * + * R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2] + */ + var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals))); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @see R.intersectionWith + * @return {Array} The list of elements found in both `list1` and `list2`. + * @example + * + * R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3] + */ + var intersection = _curry2(function intersection(list1, list2) { + return uniq(_filter(flip(_contains)(list1), list2)); + }); + + /** + * "lifts" a function of arity > 1 so that it may "map over" an Array or + * other Functor. + * + * @func + * @memberOf R + * @see R.liftN + * @category Function + * @sig (*... -> *) -> ([*]... -> [*]) + * @param {Function} fn The function to lift into higher context + * @return {Function} The function `fn` applicable to mappable objects. + * @example + * + * var madd3 = R.lift(R.curry(function(a, b, c) { + * return a + b + c; + * })); + * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] + * + * var madd5 = R.lift(R.curry(function(a, b, c, d, e) { + * return a + b + c + d + e; + * })); + * madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24] + */ + var lift = _curry1(function lift(fn) { + return liftN(fn.length, fn); + }); + + /** + * Returns a partial copy of an object omitting the keys specified. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {String: *} -> {String: *} + * @param {Array} names an array of String property names to omit from the new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with properties from `names` not on it. + * @see R.pick + * @example + * + * R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3} + */ + var omit = _curry2(function omit(names, obj) { + var result = {}; + for (var prop in obj) { + if (!_contains(prop, names)) { + result[prop] = obj[prop]; + } + } + return result; + }); + + /** + * Returns the left-to-right Kleisli composition of the provided functions, + * each of which must return a value of a type supported by [`chain`](#chain). + * + * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`. + * + * @func + * @memberOf R + * @category Function + * @see R.composeK + * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z) + * @param {...Function} + * @return {Function} + * @example + * + * // parseJson :: String -> Maybe * + * // get :: String -> Object -> Maybe * + * + * // getStateCode :: Maybe String -> Maybe String + * var getStateCode = R.pipeK( + * parseJson, + * get('user'), + * get('address'), + * get('state'), + * R.compose(Maybe.of, R.toUpper) + * ); + * + * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}')); + * //=> Just('NY') + * getStateCode(Maybe.of('[Invalid JSON]')); + * //=> Nothing() + */ + var pipeK = function pipeK() { + return composeK.apply(this, reverse(arguments)); + }; + + /** + * Returns the string representation of the given value. `eval`'ing the output + * should result in a value equivalent to the input value. Many of the built-in + * `toString` methods do not satisfy this requirement. + * + * If the given value is an `[object Object]` with a `toString` method other + * than `Object.prototype.toString`, this method is invoked with no arguments + * to produce the return value. This means user-defined constructor functions + * can provide a suitable `toString` method. For example: + * + * function Point(x, y) { + * this.x = x; + * this.y = y; + * } + * + * Point.prototype.toString = function() { + * return 'new Point(' + this.x + ', ' + this.y + ')'; + * }; + * + * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)' + * + * @func + * @memberOf R + * @category String + * @sig * -> String + * @param {*} val + * @return {String} + * @example + * + * R.toString(42); //=> '42' + * R.toString('abc'); //=> '"abc"' + * R.toString([1, 2, 3]); //=> '[1, 2, 3]' + * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}' + * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")' + */ + var toString = _curry1(function toString(val) { + return _toString(val, []); + }); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of the + * elements of each list. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} as The first list. + * @param {Array} bs The second list. + * @return {Array} The first and second lists concatenated, with + * duplicates removed. + * @example + * + * R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4] + */ + var union = _curry2(compose(uniq, _concat)); + + /** + * Returns a new list containing only one copy of each element in the + * original list, based upon the value returned by applying the supplied + * function to each list element. Prefers the first item if the supplied + * function produces the same value on two items. `R.equals` is used for + * comparison. + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [a] + * @param {Function} fn A function used to produce a value to use during comparisons. + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10] + */ + var uniqBy = _curry2(function uniqBy(fn, list) { + var idx = 0, applied = [], result = [], appliedItem, item; + while (idx < list.length) { + item = list[idx]; + appliedItem = fn(item); + if (!_contains(appliedItem, applied)) { + result.push(item); + applied.push(appliedItem); + } + idx += 1; + } + return result; + }); + + /** + * Turns a named method with a specified arity into a function + * that can be called directly supplied with arguments and a target object. + * + * The returned function is curried and accepts `arity + 1` parameters where + * the final parameter is the target object. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *) + * @param {Number} arity Number of arguments the returned function should take + * before the target object. + * @param {Function} method Name of the method to call. + * @return {Function} A new curried function. + * @example + * + * var sliceFrom = R.invoker(1, 'slice'); + * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm' + * var sliceFrom6 = R.invoker(2, 'slice')(6); + * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh' + */ + var invoker = _curry2(function invoker(arity, method) { + return curryN(arity + 1, function () { + var target = arguments[arity]; + if (target != null && is(Function, target[method])) { + return target[method].apply(target, _slice(arguments, 0, arity)); + } + throw new TypeError(toString(target) + ' does not have a method named "' + method + '"'); + }); + }); + + /** + * Returns a string made by inserting the `separator` between each + * element and concatenating all the elements into a single string. + * + * @func + * @memberOf R + * @category List + * @sig String -> [a] -> String + * @param {Number|String} separator The string used to separate the elements. + * @param {Array} xs The elements to join into a string. + * @return {String} str The string made by concatenating `xs` with `separator`. + * @see R.split + * @example + * + * var spacer = R.join(' '); + * spacer(['a', 2, 3.4]); //=> 'a 2 3.4' + * R.join('|', [1, 2, 3]); //=> '1|2|3' + */ + var join = invoker(1, 'join'); + + /** + * Creates a new function that, when invoked, caches the result of calling `fn` for a given + * argument set and returns the result. Subsequent calls to the memoized `fn` with the same + * argument set will not result in an additional call to `fn`; instead, the cached result + * for that set of arguments will be returned. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a) -> (*... -> a) + * @param {Function} fn The function to memoize. + * @return {Function} Memoized version of `fn`. + * @example + * + * var count = 0; + * var factorial = R.memoize(function(n) { + * count += 1; + * return R.product(R.range(1, n + 1)); + * }); + * factorial(5); //=> 120 + * factorial(5); //=> 120 + * factorial(5); //=> 120 + * count; //=> 1 + */ + var memoize = _curry1(function memoize(fn) { + var cache = {}; + return function () { + var key = toString(arguments); + if (!_has(key, cache)) { + cache[key] = fn.apply(this, arguments); + } + return cache[key]; + }; + }); + + /** + * Splits a string into an array of strings based on the given + * separator. + * + * @func + * @memberOf R + * @category String + * @sig String -> String -> [String] + * @param {String} sep The separator string. + * @param {String} str The string to separate into an array. + * @return {Array} The array of strings from `str` separated by `str`. + * @see R.join + * @example + * + * var pathComponents = R.split('/'); + * R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node'] + * + * R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd'] + */ + var split = invoker(1, 'split'); + + /** + * The lower case version of a string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to lower case. + * @return {String} The lower case version of `str`. + * @see R.toUpper + * @example + * + * R.toLower('XYZ'); //=> 'xyz' + */ + var toLower = invoker(0, 'toLowerCase'); + + /** + * The upper case version of a string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to upper case. + * @return {String} The upper case version of `str`. + * @see R.toLower + * @example + * + * R.toUpper('abc'); //=> 'ABC' + */ + var toUpper = invoker(0, 'toUpperCase'); + + var R = { + F: F, + T: T, + __: __, + add: add, + addIndex: addIndex, + adjust: adjust, + all: all, + allPass: allPass, + always: always, + and: and, + any: any, + anyPass: anyPass, + ap: ap, + aperture: aperture, + append: append, + apply: apply, + assoc: assoc, + assocPath: assocPath, + binary: binary, + bind: bind, + both: both, + call: call, + chain: chain, + clone: clone, + commute: commute, + commuteMap: commuteMap, + comparator: comparator, + complement: complement, + compose: compose, + composeK: composeK, + composeP: composeP, + concat: concat, + cond: cond, + construct: construct, + constructN: constructN, + contains: contains, + containsWith: containsWith, + converge: converge, + countBy: countBy, + createMapEntry: createMapEntry, + curry: curry, + curryN: curryN, + dec: dec, + defaultTo: defaultTo, + difference: difference, + differenceWith: differenceWith, + dissoc: dissoc, + dissocPath: dissocPath, + divide: divide, + drop: drop, + dropLast: dropLast, + dropLastWhile: dropLastWhile, + dropRepeats: dropRepeats, + dropRepeatsWith: dropRepeatsWith, + dropWhile: dropWhile, + either: either, + empty: empty, + eqProps: eqProps, + equals: equals, + evolve: evolve, + filter: filter, + find: find, + findIndex: findIndex, + findLast: findLast, + findLastIndex: findLastIndex, + flatten: flatten, + flip: flip, + forEach: forEach, + fromPairs: fromPairs, + functions: functions, + functionsIn: functionsIn, + groupBy: groupBy, + gt: gt, + gte: gte, + has: has, + hasIn: hasIn, + head: head, + identical: identical, + identity: identity, + ifElse: ifElse, + inc: inc, + indexOf: indexOf, + init: init, + insert: insert, + insertAll: insertAll, + intersection: intersection, + intersectionWith: intersectionWith, + intersperse: intersperse, + into: into, + invert: invert, + invertObj: invertObj, + invoker: invoker, + is: is, + isArrayLike: isArrayLike, + isEmpty: isEmpty, + isNil: isNil, + isSet: isSet, + join: join, + keys: keys, + keysIn: keysIn, + last: last, + lastIndexOf: lastIndexOf, + length: length, + lens: lens, + lensIndex: lensIndex, + lensProp: lensProp, + lift: lift, + liftN: liftN, + lt: lt, + lte: lte, + map: map, + mapAccum: mapAccum, + mapAccumRight: mapAccumRight, + mapObj: mapObj, + mapObjIndexed: mapObjIndexed, + match: match, + mathMod: mathMod, + max: max, + maxBy: maxBy, + mean: mean, + median: median, + memoize: memoize, + merge: merge, + mergeAll: mergeAll, + min: min, + minBy: minBy, + modulo: modulo, + multiply: multiply, + nAry: nAry, + negate: negate, + none: none, + not: not, + nth: nth, + nthArg: nthArg, + nthChar: nthChar, + nthCharCode: nthCharCode, + of: of, + omit: omit, + once: once, + or: or, + over: over, + partial: partial, + partialRight: partialRight, + partition: partition, + path: path, + pathEq: pathEq, + pick: pick, + pickAll: pickAll, + pickBy: pickBy, + pipe: pipe, + pipeK: pipeK, + pipeP: pipeP, + pluck: pluck, + prepend: prepend, + product: product, + project: project, + prop: prop, + propEq: propEq, + propIs: propIs, + propOr: propOr, + propSatisfies: propSatisfies, + props: props, + range: range, + reduce: reduce, + reduceRight: reduceRight, + reduced: reduced, + reject: reject, + remove: remove, + repeat: repeat, + replace: replace, + reverse: reverse, + scan: scan, + set: set, + slice: slice, + sort: sort, + sortBy: sortBy, + split: split, + splitEvery: splitEvery, + subtract: subtract, + sum: sum, + tail: tail, + take: take, + takeLast: takeLast, + takeLastWhile: takeLastWhile, + takeWhile: takeWhile, + tap: tap, + test: test, + times: times, + toLower: toLower, + toPairs: toPairs, + toPairsIn: toPairsIn, + toString: toString, + toUpper: toUpper, + transduce: transduce, + trim: trim, + type: type, + unapply: unapply, + unary: unary, + uncurryN: uncurryN, + unfold: unfold, + union: union, + unionWith: unionWith, + uniq: uniq, + uniqBy: uniqBy, + uniqWith: uniqWith, + unnest: unnest, + update: update, + useWith: useWith, + values: values, + valuesIn: valuesIn, + view: view, + where: where, + whereEq: whereEq, + wrap: wrap, + xprod: xprod, + zip: zip, + zipObj: zipObj, + zipWith: zipWith + }; + + /* TEST_ENTRY_POINT */ + + if (typeof exports === 'object') { + module.exports = R; + } else if (typeof define === 'function' && define.amd) { + define(function() { return R; }); + } else { + this.R = R; + } + +}.call(this)); + +},{}],8:[function(require,module,exports){ +var always = require('./always'); + + +/** + * A function that always returns `true`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> true + * @return {Boolean} `true`. + * @see R.always, R.F + * @example + * + * R.T(); //=> true + */ +module.exports = always(true); + +},{"./always":12}],9:[function(require,module,exports){ +/** + * A special placeholder value used to specify "gaps" within curried functions, + * allowing partial application of any combination of arguments, + * regardless of their positions. + * + * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2, _)(1, 3)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @constant + * @memberOf R + * @category Function + * @example + * + * var greet = R.replace('{name}', R.__, 'Hello, {name}!'); + * greet('Alice'); //=> 'Hello, Alice!' + */ +module.exports = {'@@functional/placeholder': true}; + +},{}],10:[function(require,module,exports){ +var _concat = require('./internal/_concat'); +var _curry3 = require('./internal/_curry3'); + +/** + * Applies a function to the value at the given index of an array, + * returning a new copy of the array with the element at the given + * index replaced with the result of the function application. + * @see R.update + * + * @func + * @memberOf R + * @category List + * @sig (a -> a) -> Number -> [a] -> [a] + * @param {Function} fn The function to apply. + * @param {Number} idx The index. + * @param {Array|Arguments} list An array-like object whose value + * at the supplied index will be replaced. + * @return {Array} A copy of the supplied array-like object with + * the element at index `idx` replaced with the value + * returned by applying `fn` to the existing element. + * @example + * + * R.adjust(R.add(10), 1, [0, 1, 2]); //=> [0, 11, 2] + * R.adjust(R.add(10))(1)([0, 1, 2]); //=> [0, 11, 2] + */ +module.exports = _curry3(function adjust(fn, idx, list) { + if (idx >= list.length || idx < -list.length) { + return list; + } + var start = idx < 0 ? list.length : 0; + var _idx = start + idx; + var _list = _concat(list); + _list[_idx] = fn(list[_idx]); + return _list; +}); + +},{"./internal/_concat":22,"./internal/_curry3":25}],11:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _dispatchable = require('./internal/_dispatchable'); +var _xall = require('./internal/_xall'); + + +/** + * Returns `true` if all elements of the list match the predicate, `false` if there are any + * that don't. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is satisfied by every element, `false` + * otherwise. + * @see R.any, R.none + * @example + * + * var lessThan2 = R.flip(R.lt)(2); + * var lessThan3 = R.flip(R.lt)(3); + * R.all(lessThan2)([1, 2]); //=> false + * R.all(lessThan3)([1, 2]); //=> true + */ +module.exports = _curry2(_dispatchable('all', _xall, function all(fn, list) { + var idx = 0; + while (idx < list.length) { + if (!fn(list[idx])) { + return false; + } + idx += 1; + } + return true; +})); + +},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_xall":36}],12:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); + + +/** + * Returns a function that always returns the given value. Note that for + * non-primitives the value returned is a reference to the original value. + * + * This function is known as `const`, `constant`, or `K` (for K combinator) + * in other languages and libraries. + * + * @func + * @memberOf R + * @category Function + * @sig a -> (* -> a) + * @param {*} val The value to wrap in a function + * @return {Function} A Function :: * -> val. + * @example + * + * var t = R.always('Tee'); + * t(); //=> 'Tee' + */ +module.exports = _curry1(function always(val) { + return function() { + return val; + }; +}); + +},{"./internal/_curry1":23}],13:[function(require,module,exports){ +var _concat = require('./internal/_concat'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns a new list containing the contents of the given list, followed by the given + * element. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The element to add to the end of the new list. + * @param {Array} list The list whose contents will be added to the beginning of the output + * list. + * @return {Array} A new list containing the contents of the old list followed by `el`. + * @see R.prepend + * @example + * + * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests'] + * R.append('tests', []); //=> ['tests'] + * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] + */ +module.exports = _curry2(function append(el, list) { + return _concat(list, [el]); +}); + +},{"./internal/_concat":22,"./internal/_curry2":24}],14:[function(require,module,exports){ +var _arity = require('./internal/_arity'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Creates a function that is bound to a context. + * Note: `R.bind` does not provide the additional argument-binding capabilities of + * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind). + * + * @func + * @memberOf R + * @category Function + * @category Object + * @see R.partial + * @sig (* -> *) -> {*} -> (* -> *) + * @param {Function} fn The function to bind to context + * @param {Object} thisObj The context to bind `fn` to + * @return {Function} A function that will execute in the context of `thisObj`. + */ +module.exports = _curry2(function bind(fn, thisObj) { + return _arity(fn.length, function() { + return fn.apply(thisObj, arguments); + }); +}); + +},{"./internal/_arity":20,"./internal/_curry2":24}],15:[function(require,module,exports){ +var pipe = require('./pipe'); +var reverse = require('./reverse'); + + +/** + * Performs right-to-left function composition. The rightmost function may have + * any arity; the remaining functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.pipe + * @example + * + * var f = R.compose(R.inc, R.negate, Math.pow); + * + * f(3, 4); // -(3^4) + 1 + */ +module.exports = function compose() { + if (arguments.length === 0) { + throw new Error('compose requires at least one argument'); + } + return pipe.apply(this, reverse(arguments)); +}; + +},{"./pipe":45,"./reverse":47}],16:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var curryN = require('./curryN'); + + +/** + * Returns a curried equivalent of the provided function. The curried + * function has two unusual capabilities. First, its arguments needn't + * be provided one at a time. If `f` is a ternary function and `g` is + * `R.curry(f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig (* -> a) -> (* -> a) + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curryN + * @example + * + * var addFourNumbers = function(a, b, c, d) { + * return a + b + c + d; + * }; + * + * var curriedAddFourNumbers = R.curry(addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry1(function curry(fn) { + return curryN(fn.length, fn); +}); + +},{"./curryN":17,"./internal/_curry1":23}],17:[function(require,module,exports){ +var _arity = require('./internal/_arity'); +var _curry1 = require('./internal/_curry1'); +var _curry2 = require('./internal/_curry2'); +var _curryN = require('./internal/_curryN'); + + +/** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry2(function curryN(length, fn) { + if (length === 1) { + return _curry1(fn); + } + return _arity(length, _curryN(length, [], fn)); +}); + +},{"./internal/_arity":20,"./internal/_curry1":23,"./internal/_curry2":24,"./internal/_curryN":26}],18:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Creates a new object by recursively evolving a shallow copy of `object`, according to the + * `transformation` functions. All non-primitive properties are copied by reference. + * + * A `tranformation` function will not be invoked if its corresponding key does not exist in + * the evolved object. + * + * @func + * @memberOf R + * @category Object + * @sig {k: (v -> v)} -> {k: v} -> {k: v} + * @param {Object} transformations The object specifying transformation functions to apply + * to the object. + * @param {Object} object The object to be transformed. + * @return {Object} The transformed object. + * @example + * + * var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123}; + * var transformations = { + * firstName: R.trim, + * lastName: R.trim, // Will not get invoked. + * data: {elapsed: R.add(1), remaining: R.add(-1)} + * }; + * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} + */ +module.exports = _curry2(function evolve(transformations, object) { + var transformation, key, type, result = {}; + for (key in object) { + transformation = transformations[key]; + type = typeof transformation; + result[key] = type === 'function' ? transformation(object[key]) + : type === 'object' ? evolve(transformations[key], object[key]) + : object[key]; + } + return result; +}); + +},{"./internal/_curry2":24}],19:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _dispatchable = require('./internal/_dispatchable'); +var _xfind = require('./internal/_xfind'); + + +/** + * Returns the first element of the list which matches the predicate, or `undefined` if no + * element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> a | undefined + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Object} The element found, or `undefined`. + * @example + * + * var xs = [{a: 1}, {a: 2}, {a: 3}]; + * R.find(R.propEq('a', 2))(xs); //=> {a: 2} + * R.find(R.propEq('a', 4))(xs); //=> undefined + */ +module.exports = _curry2(_dispatchable('find', _xfind, function find(fn, list) { + var idx = 0; + var len = list.length; + while (idx < len) { + if (fn(list[idx])) { + return list[idx]; + } + idx += 1; + } +})); + +},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_xfind":38}],20:[function(require,module,exports){ +module.exports = function _arity(n, fn) { + // jshint unused:vars + switch (n) { + case 0: return function() { return fn.apply(this, arguments); }; + case 1: return function(a0) { return fn.apply(this, arguments); }; + case 2: return function(a0, a1) { return fn.apply(this, arguments); }; + case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; + case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; + case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; + case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; + case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; + case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; + case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; + case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; + default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); + } +}; + +},{}],21:[function(require,module,exports){ +var _isArray = require('./_isArray'); +var _slice = require('./_slice'); + + +/** + * Similar to hasMethod, this checks whether a function has a [methodname] + * function. If it isn't an array it will execute that function otherwise it will + * default to the ramda implementation. + * + * @private + * @param {Function} fn ramda implemtation + * @param {String} methodname property to check for a custom implementation + * @return {Object} Whatever the return value of the method is. + */ +module.exports = function _checkForMethod(methodname, fn) { + return function() { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + return (_isArray(obj) || typeof obj[methodname] !== 'function') ? + fn.apply(this, arguments) : + obj[methodname].apply(obj, _slice(arguments, 0, length - 1)); + }; +}; + +},{"./_isArray":29,"./_slice":35}],22:[function(require,module,exports){ +/** + * Private `concat` function to merge two array-like objects. + * + * @private + * @param {Array|Arguments} [set1=[]] An array-like object. + * @param {Array|Arguments} [set2=[]] An array-like object. + * @return {Array} A new, merged array. + * @example + * + * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + */ +module.exports = function _concat(set1, set2) { + set1 = set1 || []; + set2 = set2 || []; + var idx; + var len1 = set1.length; + var len2 = set2.length; + var result = []; + + idx = 0; + while (idx < len1) { + result[result.length] = set1[idx]; + idx += 1; + } + idx = 0; + while (idx < len2) { + result[result.length] = set2[idx]; + idx += 1; + } + return result; +}; + +},{}],23:[function(require,module,exports){ +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn.apply(this, arguments); + } + }; +}; + +},{}],24:[function(require,module,exports){ +var _curry1 = require('./_curry1'); + + +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry2(fn) { + return function f2(a, b) { + var n = arguments.length; + if (n === 0) { + return f2; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f2; + } else if (n === 1) { + return _curry1(function(b) { return fn(a, b); }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return f2; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function(a) { return fn(a, b); }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function(b) { return fn(a, b); }); + } else { + return fn(a, b); + } + }; +}; + +},{"./_curry1":23}],25:[function(require,module,exports){ +var _curry1 = require('./_curry1'); +var _curry2 = require('./_curry2'); + + +/** + * Optimized internal three-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry3(fn) { + return function f3(a, b, c) { + var n = arguments.length; + if (n === 0) { + return f3; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f3; + } else if (n === 1) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return f3; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry2(function(a, c) { return fn(a, b, c); }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 2) { + return _curry1(function(c) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return f3; + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return _curry2(function(a, b) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return _curry2(function(a, c) { return fn(a, b, c); }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function(a) { return fn(a, b, c); }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function(b) { return fn(a, b, c); }); + } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) { + return _curry1(function(c) { return fn(a, b, c); }); + } else { + return fn(a, b, c); + } + }; +}; + +},{"./_curry1":23,"./_curry2":24}],26:[function(require,module,exports){ +var _arity = require('./_arity'); + + +/** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ +module.exports = function _curryN(length, received, fn) { + return function() { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && + (received[combinedIdx] == null || + received[combinedIdx]['@@functional/placeholder'] !== true || + argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn)); + }; +}; + +},{"./_arity":20}],27:[function(require,module,exports){ +var _isArray = require('./_isArray'); +var _isTransformer = require('./_isTransformer'); +var _slice = require('./_slice'); + + +/** + * Returns a function that dispatches with different strategies based on the + * object in list position (last argument). If it is an array, executes [fn]. + * Otherwise, if it has a function with [methodname], it will execute that + * function (functor case). Otherwise, if it is a transformer, uses transducer + * [xf] to return a new transformer (transducer case). Otherwise, it will + * default to executing [fn]. + * + * @private + * @param {String} methodname property to check for a custom implementation + * @param {Function} xf transducer to initialize if object is transformer + * @param {Function} fn default ramda implementation + * @return {Function} A function that dispatches on object in list position + */ +module.exports = function _dispatchable(methodname, xf, fn) { + return function() { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + if (!_isArray(obj)) { + var args = _slice(arguments, 0, length - 1); + if (typeof obj[methodname] === 'function') { + return obj[methodname].apply(obj, args); + } + if (_isTransformer(obj)) { + var transducer = xf.apply(null, args); + return transducer(obj); + } + } + return fn.apply(this, arguments); + }; +}; + +},{"./_isArray":29,"./_isTransformer":30,"./_slice":35}],28:[function(require,module,exports){ +module.exports = function _has(prop, obj) { + return Object.prototype.hasOwnProperty.call(obj, prop); +}; + +},{}],29:[function(require,module,exports){ +/** + * Tests whether or not an object is an array. + * + * @private + * @param {*} val The object to test. + * @return {Boolean} `true` if `val` is an array, `false` otherwise. + * @example + * + * _isArray([]); //=> true + * _isArray(null); //=> false + * _isArray({}); //=> false + */ +module.exports = Array.isArray || function _isArray(val) { + return (val != null && + val.length >= 0 && + Object.prototype.toString.call(val) === '[object Array]'); +}; + +},{}],30:[function(require,module,exports){ +module.exports = function _isTransformer(obj) { + return typeof obj['@@transducer/step'] === 'function'; +}; + +},{}],31:[function(require,module,exports){ +module.exports = function _map(fn, list) { + var idx = 0, len = list.length, result = Array(len); + while (idx < len) { + result[idx] = fn(list[idx]); + idx += 1; + } + return result; +}; + +},{}],32:[function(require,module,exports){ +module.exports = function _pipe(f, g) { + return function() { + return g.call(this, f.apply(this, arguments)); + }; +}; + +},{}],33:[function(require,module,exports){ +var _xwrap = require('./_xwrap'); +var bind = require('../bind'); +var isArrayLike = require('../isArrayLike'); + + +module.exports = (function() { + function _arrayReduce(xf, acc, list) { + var idx = 0, len = list.length; + while (idx < len) { + acc = xf['@@transducer/step'](acc, list[idx]); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + idx += 1; + } + return xf['@@transducer/result'](acc); + } + + function _iterableReduce(xf, acc, iter) { + var step = iter.next(); + while (!step.done) { + acc = xf['@@transducer/step'](acc, step.value); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + step = iter.next(); + } + return xf['@@transducer/result'](acc); + } + + function _methodReduce(xf, acc, obj) { + return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc)); + } + + var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator'; + return function _reduce(fn, acc, list) { + if (typeof fn === 'function') { + fn = _xwrap(fn); + } + if (isArrayLike(list)) { + return _arrayReduce(fn, acc, list); + } + if (typeof list.reduce === 'function') { + return _methodReduce(fn, acc, list); + } + if (list[symIterator] != null) { + return _iterableReduce(fn, acc, list[symIterator]()); + } + if (typeof list.next === 'function') { + return _iterableReduce(fn, acc, list); + } + throw new TypeError('reduce: list must be array or iterable'); + }; +})(); + +},{"../bind":14,"../isArrayLike":41,"./_xwrap":40}],34:[function(require,module,exports){ +module.exports = function _reduced(x) { + return x && x['@@transducer/reduced'] ? x : + { + '@@transducer/value': x, + '@@transducer/reduced': true + }; +}; + +},{}],35:[function(require,module,exports){ +/** + * An optimized, private array `slice` implementation. + * + * @private + * @param {Arguments|Array} args The array or arguments object to consider. + * @param {Number} [from=0] The array index to slice from, inclusive. + * @param {Number} [to=args.length] The array index to slice to, exclusive. + * @return {Array} A new, sliced array. + * @example + * + * _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3] + * + * var firstThreeArgs = function(a, b, c, d) { + * return _slice(arguments, 0, 3); + * }; + * firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3] + */ +module.exports = function _slice(args, from, to) { + switch (arguments.length) { + case 1: return _slice(args, 0, args.length); + case 2: return _slice(args, from, args.length); + default: + var list = []; + var idx = 0; + var len = Math.max(0, Math.min(args.length, to) - from); + while (idx < len) { + list[idx] = args[from + idx]; + idx += 1; + } + return list; + } +}; + +},{}],36:[function(require,module,exports){ +var _curry2 = require('./_curry2'); +var _reduced = require('./_reduced'); +var _xfBase = require('./_xfBase'); + + +module.exports = (function() { + function XAll(f, xf) { + this.xf = xf; + this.f = f; + this.all = true; + } + XAll.prototype['@@transducer/init'] = _xfBase.init; + XAll.prototype['@@transducer/result'] = function(result) { + if (this.all) { + result = this.xf['@@transducer/step'](result, true); + } + return this.xf['@@transducer/result'](result); + }; + XAll.prototype['@@transducer/step'] = function(result, input) { + if (!this.f(input)) { + this.all = false; + result = _reduced(this.xf['@@transducer/step'](result, false)); + } + return result; + }; + + return _curry2(function _xall(f, xf) { return new XAll(f, xf); }); +})(); + +},{"./_curry2":24,"./_reduced":34,"./_xfBase":37}],37:[function(require,module,exports){ +module.exports = { + init: function() { + return this.xf['@@transducer/init'](); + }, + result: function(result) { + return this.xf['@@transducer/result'](result); + } +}; + +},{}],38:[function(require,module,exports){ +var _curry2 = require('./_curry2'); +var _reduced = require('./_reduced'); +var _xfBase = require('./_xfBase'); + + +module.exports = (function() { + function XFind(f, xf) { + this.xf = xf; + this.f = f; + this.found = false; + } + XFind.prototype['@@transducer/init'] = _xfBase.init; + XFind.prototype['@@transducer/result'] = function(result) { + if (!this.found) { + result = this.xf['@@transducer/step'](result, void 0); + } + return this.xf['@@transducer/result'](result); + }; + XFind.prototype['@@transducer/step'] = function(result, input) { + if (this.f(input)) { + this.found = true; + result = _reduced(this.xf['@@transducer/step'](result, input)); + } + return result; + }; + + return _curry2(function _xfind(f, xf) { return new XFind(f, xf); }); +})(); + +},{"./_curry2":24,"./_reduced":34,"./_xfBase":37}],39:[function(require,module,exports){ +var _curry2 = require('./_curry2'); +var _xfBase = require('./_xfBase'); + + +module.exports = (function() { + function XMap(f, xf) { + this.xf = xf; + this.f = f; + } + XMap.prototype['@@transducer/init'] = _xfBase.init; + XMap.prototype['@@transducer/result'] = _xfBase.result; + XMap.prototype['@@transducer/step'] = function(result, input) { + return this.xf['@@transducer/step'](result, this.f(input)); + }; + + return _curry2(function _xmap(f, xf) { return new XMap(f, xf); }); +})(); + +},{"./_curry2":24,"./_xfBase":37}],40:[function(require,module,exports){ +module.exports = (function() { + function XWrap(fn) { + this.f = fn; + } + XWrap.prototype['@@transducer/init'] = function() { + throw new Error('init not implemented on XWrap'); + }; + XWrap.prototype['@@transducer/result'] = function(acc) { return acc; }; + XWrap.prototype['@@transducer/step'] = function(acc, x) { + return this.f(acc, x); + }; + + return function _xwrap(fn) { return new XWrap(fn); }; +}()); + +},{}],41:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _isArray = require('./internal/_isArray'); + + +/** + * Tests whether or not an object is similar to an array. + * + * @func + * @memberOf R + * @category Type + * @category List + * @sig * -> Boolean + * @param {*} x The object to test. + * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise. + * @example + * + * R.isArrayLike([]); //=> true + * R.isArrayLike(true); //=> false + * R.isArrayLike({}); //=> false + * R.isArrayLike({length: 10}); //=> false + * R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true + */ +module.exports = _curry1(function isArrayLike(x) { + if (_isArray(x)) { return true; } + if (!x) { return false; } + if (typeof x !== 'object') { return false; } + if (x instanceof String) { return false; } + if (x.nodeType === 1) { return !!x.length; } + if (x.length === 0) { return true; } + if (x.length > 0) { + return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1); + } + return false; +}); + +},{"./internal/_curry1":23,"./internal/_isArray":29}],42:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _has = require('./internal/_has'); + + +/** + * Returns a list containing the names of all the enumerable own + * properties of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own properties. + * @example + * + * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] + */ +module.exports = (function() { + // cover IE < 9 keys issues + var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString'); + var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', + 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; + + var contains = function contains(list, item) { + var idx = 0; + while (idx < list.length) { + if (list[idx] === item) { + return true; + } + idx += 1; + } + return false; + }; + + return typeof Object.keys === 'function' ? + _curry1(function keys(obj) { + return Object(obj) !== obj ? [] : Object.keys(obj); + }) : + _curry1(function keys(obj) { + if (Object(obj) !== obj) { + return []; + } + var prop, ks = [], nIdx; + for (prop in obj) { + if (_has(prop, obj)) { + ks[ks.length] = prop; + } + } + if (hasEnumBug) { + nIdx = nonEnumerableProps.length - 1; + while (nIdx >= 0) { + prop = nonEnumerableProps[nIdx]; + if (_has(prop, obj) && !contains(ks, prop)) { + ks[ks.length] = prop; + } + nIdx -= 1; + } + } + return ks; + }); +}()); + +},{"./internal/_curry1":23,"./internal/_has":28}],43:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _dispatchable = require('./internal/_dispatchable'); +var _map = require('./internal/_map'); +var _xmap = require('./internal/_xmap'); + + +/** + * Returns a new list, constructed by applying the supplied function to every element of the + * supplied list. + * + * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the + * native `Array.prototype.map` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [b] + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {Array} list The list to be iterated over. + * @return {Array} The new list. + * @example + * + * var double = function(x) { + * return x * 2; + * }; + * + * R.map(double, [1, 2, 3]); //=> [2, 4, 6] + */ +module.exports = _curry2(_dispatchable('map', _xmap, _map)); + +},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_map":31,"./internal/_xmap":39}],44:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var keys = require('./keys'); + + +/** + * Create a new object with the own properties of `a` + * merged with the own properties of object `b`. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> {k: v} -> {k: v} + * @param {Object} a + * @param {Object} b + * @return {Object} + * @example + * + * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); + * //=> { 'name': 'fred', 'age': 40 } + * + * var resetToDefault = R.merge(R.__, {x: 0}); + * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} + */ +module.exports = _curry2(function merge(a, b) { + var result = {}; + var ks = keys(a); + var idx = 0; + while (idx < ks.length) { + result[ks[idx]] = a[ks[idx]]; + idx += 1; + } + ks = keys(b); + idx = 0; + while (idx < ks.length) { + result[ks[idx]] = b[ks[idx]]; + idx += 1; + } + return result; +}); + +},{"./internal/_curry2":24,"./keys":42}],45:[function(require,module,exports){ +var _pipe = require('./internal/_pipe'); +var curryN = require('./curryN'); +var reduce = require('./reduce'); +var tail = require('./tail'); + + +/** + * Performs left-to-right function composition. The leftmost function may have + * any arity; the remaining functions must be unary. + * + * In some libraries this function is named `sequence`. + * + * @func + * @memberOf R + * @category Function + * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.compose + * @example + * + * var f = R.pipe(Math.pow, R.negate, R.inc); + * + * f(3, 4); // -(3^4) + 1 + */ +module.exports = function pipe() { + if (arguments.length === 0) { + throw new Error('pipe requires at least one argument'); + } + return curryN(arguments[0].length, + reduce(_pipe, arguments[0], tail(arguments))); +}; + +},{"./curryN":17,"./internal/_pipe":32,"./reduce":46,"./tail":49}],46:[function(require,module,exports){ +var _curry3 = require('./internal/_curry3'); +var _reduce = require('./internal/_reduce'); + + +/** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It may use `R.reduced` to + * shortcut the iteration. + * + * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description + * @see R.reduced + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3]; + * var add = function(a, b) { + * return a + b; + * }; + * + * R.reduce(add, 10, numbers); //=> 16 + */ +module.exports = _curry3(_reduce); + +},{"./internal/_curry3":25,"./internal/_reduce":33}],47:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _slice = require('./internal/_slice'); + + +/** + * Returns a new list with the same elements as the original list, just + * in the reverse order. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The list to reverse. + * @return {Array} A copy of the list in reverse order. + * @example + * + * R.reverse([1, 2, 3]); //=> [3, 2, 1] + * R.reverse([1, 2]); //=> [2, 1] + * R.reverse([1]); //=> [1] + * R.reverse([]); //=> [] + */ +module.exports = _curry1(function reverse(list) { + return _slice(list).reverse(); +}); + +},{"./internal/_curry1":23,"./internal/_slice":35}],48:[function(require,module,exports){ +var _checkForMethod = require('./internal/_checkForMethod'); +var _curry3 = require('./internal/_curry3'); + + +/** + * Returns the elements of the given list or string (or object with a `slice` + * method) from `fromIndex` (inclusive) to `toIndex` (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @sig Number -> Number -> String -> String + * @param {Number} fromIndex The start index (inclusive). + * @param {Number} toIndex The end index (exclusive). + * @param {*} list + * @return {*} + * @example + * + * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] + * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] + * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(0, 3, 'ramda'); //=> 'ram' + */ +module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) { + return Array.prototype.slice.call(list, fromIndex, toIndex); +})); + +},{"./internal/_checkForMethod":21,"./internal/_curry3":25}],49:[function(require,module,exports){ +var _checkForMethod = require('./internal/_checkForMethod'); +var slice = require('./slice'); + + +/** + * Returns all but the first element of the given list or string (or object + * with a `tail` method). + * + * @func + * @memberOf R + * @category List + * @see R.head, R.init, R.last + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.tail([1, 2, 3]); //=> [2, 3] + * R.tail([1, 2]); //=> [2] + * R.tail([1]); //=> [] + * R.tail([]); //=> [] + * + * R.tail('abc'); //=> 'bc' + * R.tail('ab'); //=> 'b' + * R.tail('a'); //=> '' + * R.tail(''); //=> '' + */ +module.exports = _checkForMethod('tail', slice(1, Infinity)); + +},{"./internal/_checkForMethod":21,"./slice":48}],50:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Creates a new list out of the two supplied by pairing up + * equally-positioned items from both lists. The returned list is + * truncated to the length of the shorter of the two input lists. + * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] -> [[a,b]] + * @param {Array} list1 The first array to consider. + * @param {Array} list2 The second array to consider. + * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`. + * @example + * + * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']] + */ +module.exports = _curry2(function zip(a, b) { + var rv = []; + var idx = 0; + var len = Math.min(a.length, b.length); + while (idx < len) { + rv[idx] = [a[idx], b[idx]]; + idx += 1; + } + return rv; +}); + +},{"./internal/_curry2":24}],51:[function(require,module,exports){ +var VNode = require('./vnode'); +var is = require('./is'); + +module.exports = function h(sel, b, c) { + var data = {}, children, text, i; + if (arguments.length === 3) { + data = b; + if (is.array(c)) { children = c; } + else if (is.primitive(c)) { text = c; } + } else if (arguments.length === 2) { + if (is.array(b)) { children = b; } + else if (is.primitive(b)) { text = b; } + else { data = b; } + } + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]); + } + } + return VNode(sel, data, children, text, undefined); +}; + +},{"./is":52,"./vnode":53}],52:[function(require,module,exports){ +module.exports = { + array: Array.isArray, + primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; }, +}; + +},{}],53:[function(require,module,exports){ +module.exports = function(sel, data, children, text, elm) { + var key = data === undefined ? undefined : data.key; + return {sel: sel, data: data, children: children, + text: text, elm: elm, key: key}; +}; + +},{}],54:[function(require,module,exports){ +(function (process){ +var defined = require('defined'); +var createDefaultStream = require('./lib/default_stream'); +var Test = require('./lib/test'); +var createResult = require('./lib/results'); +var through = require('through'); + +var canEmitExit = typeof process !== 'undefined' && process + && typeof process.on === 'function' && process.browser !== true +; +var canExit = typeof process !== 'undefined' && process + && typeof process.exit === 'function' +; + +var nextTick = typeof setImmediate !== 'undefined' + ? setImmediate + : process.nextTick +; + +exports = module.exports = (function () { + var harness; + var lazyLoad = function () { + return getHarness().apply(this, arguments); + }; + + lazyLoad.only = function () { + return getHarness().only.apply(this, arguments); + }; + + lazyLoad.createStream = function (opts) { + if (!opts) opts = {}; + if (!harness) { + var output = through(); + getHarness({ stream: output, objectMode: opts.objectMode }); + return output; + } + return harness.createStream(opts); + }; + + lazyLoad.getHarness = getHarness + + return lazyLoad + + function getHarness (opts) { + if (!opts) opts = {}; + opts.autoclose = !canEmitExit; + if (!harness) harness = createExitHarness(opts); + return harness; + } +})(); + +function createExitHarness (conf) { + if (!conf) conf = {}; + var harness = createHarness({ + autoclose: defined(conf.autoclose, false) + }); + + var stream = harness.createStream({ objectMode: conf.objectMode }); + var es = stream.pipe(conf.stream || createDefaultStream()); + if (canEmitExit) { + es.on('error', function (err) { harness._exitCode = 1 }); + } + + var ended = false; + stream.on('end', function () { ended = true }); + + if (conf.exit === false) return harness; + if (!canEmitExit || !canExit) return harness; + + var inErrorState = false; + + process.on('exit', function (code) { + // let the process exit cleanly. + if (code !== 0) { + return + } + + if (!ended) { + var only = harness._results._only; + for (var i = 0; i < harness._tests.length; i++) { + var t = harness._tests[i]; + if (only && t.name !== only) continue; + t._exit(); + } + } + harness.close(); + process.exit(code || harness._exitCode); + }); + + return harness; +} + +exports.createHarness = createHarness; +exports.Test = Test; +exports.test = exports; // tap compat +exports.test.skip = Test.skip; + +var exitInterval; + +function createHarness (conf_) { + if (!conf_) conf_ = {}; + var results = createResult(); + if (conf_.autoclose !== false) { + results.once('done', function () { results.close() }); + } + + var test = function (name, conf, cb) { + var t = new Test(name, conf, cb); + test._tests.push(t); + + (function inspectCode (st) { + st.on('test', function sub (st_) { + inspectCode(st_); + }); + st.on('result', function (r) { + if (!r.ok && typeof r !== 'string') test._exitCode = 1 + }); + })(t); + + results.push(t); + return t; + }; + test._results = results; + + test._tests = []; + + test.createStream = function (opts) { + return results.createStream(opts); + }; + + var only = false; + test.only = function (name) { + if (only) throw new Error('there can only be one only test'); + results.only(name); + only = true; + return test.apply(null, arguments); + }; + test._exitCode = 0; + + test.close = function () { results.close() }; + + return test; +} + +}).call(this,require('_process')) +},{"./lib/default_stream":55,"./lib/results":56,"./lib/test":57,"_process":84,"defined":61,"through":67}],55:[function(require,module,exports){ +(function (process){ +var through = require('through'); +var fs = require('fs'); + +module.exports = function () { + var line = ''; + var stream = through(write, flush); + return stream; + + function write (buf) { + for (var i = 0; i < buf.length; i++) { + var c = typeof buf === 'string' + ? buf.charAt(i) + : String.fromCharCode(buf[i]) + ; + if (c === '\n') flush(); + else line += c; + } + } + + function flush () { + if (fs.writeSync && /^win/.test(process.platform)) { + try { fs.writeSync(1, line + '\n'); } + catch (e) { stream.emit('error', e) } + } + else { + try { console.log(line) } + catch (e) { stream.emit('error', e) } + } + line = ''; + } +}; + +}).call(this,require('_process')) +},{"_process":84,"fs":74,"through":67}],56:[function(require,module,exports){ +(function (process){ +var EventEmitter = require('events').EventEmitter; +var inherits = require('inherits'); +var through = require('through'); +var resumer = require('resumer'); +var inspect = require('object-inspect'); +var bind = require('function-bind'); +var has = require('has'); +var regexpTest = bind.call(Function.call, RegExp.prototype.test); +var yamlIndicators = /\:|\-|\?/; +var nextTick = typeof setImmediate !== 'undefined' + ? setImmediate + : process.nextTick +; + +module.exports = Results; +inherits(Results, EventEmitter); + +function Results () { + if (!(this instanceof Results)) return new Results; + this.count = 0; + this.fail = 0; + this.pass = 0; + this._stream = through(); + this.tests = []; +} + +Results.prototype.createStream = function (opts) { + if (!opts) opts = {}; + var self = this; + var output, testId = 0; + if (opts.objectMode) { + output = through(); + self.on('_push', function ontest (t, extra) { + if (!extra) extra = {}; + var id = testId++; + t.once('prerun', function () { + var row = { + type: 'test', + name: t.name, + id: id + }; + if (has(extra, 'parent')) { + row.parent = extra.parent; + } + output.queue(row); + }); + t.on('test', function (st) { + ontest(st, { parent: id }); + }); + t.on('result', function (res) { + res.test = id; + res.type = 'assert'; + output.queue(res); + }); + t.on('end', function () { + output.queue({ type: 'end', test: id }); + }); + }); + self.on('done', function () { output.queue(null) }); + } + else { + output = resumer(); + output.queue('TAP version 13\n'); + self._stream.pipe(output); + } + + nextTick(function next() { + var t; + while (t = getNextTest(self)) { + t.run(); + if (!t.ended) return t.once('end', function(){ nextTick(next); }); + } + self.emit('done'); + }); + + return output; +}; + +Results.prototype.push = function (t) { + var self = this; + self.tests.push(t); + self._watch(t); + self.emit('_push', t); +}; + +Results.prototype.only = function (name) { + if (this._only) { + self.count ++; + self.fail ++; + write('not ok ' + self.count + ' already called .only()\n'); + } + this._only = name; +}; + +Results.prototype._watch = function (t) { + var self = this; + var write = function (s) { self._stream.queue(s) }; + t.once('prerun', function () { + write('# ' + t.name + '\n'); + }); + + t.on('result', function (res) { + if (typeof res === 'string') { + write('# ' + res + '\n'); + return; + } + write(encodeResult(res, self.count + 1)); + self.count ++; + + if (res.ok) self.pass ++ + else self.fail ++ + }); + + t.on('test', function (st) { self._watch(st) }); +}; + +Results.prototype.close = function () { + var self = this; + if (self.closed) self._stream.emit('error', new Error('ALREADY CLOSED')); + self.closed = true; + var write = function (s) { self._stream.queue(s) }; + + write('\n1..' + self.count + '\n'); + write('# tests ' + self.count + '\n'); + write('# pass ' + self.pass + '\n'); + if (self.fail) write('# fail ' + self.fail + '\n') + else write('\n# ok\n') + + self._stream.queue(null); +}; + +function encodeResult (res, count) { + var output = ''; + output += (res.ok ? 'ok ' : 'not ok ') + count; + output += res.name ? ' ' + res.name.toString().replace(/\s+/g, ' ') : ''; + + if (res.skip) output += ' # SKIP'; + else if (res.todo) output += ' # TODO'; + + output += '\n'; + if (res.ok) return output; + + var outer = ' '; + var inner = outer + ' '; + output += outer + '---\n'; + output += inner + 'operator: ' + res.operator + '\n'; + + if (has(res, 'expected') || has(res, 'actual')) { + var ex = inspect(res.expected); + var ac = inspect(res.actual); + + if (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) { + output += inner + 'expected: |-\n' + inner + ' ' + ex + '\n'; + output += inner + 'actual: |-\n' + inner + ' ' + ac + '\n'; + } + else { + output += inner + 'expected: ' + ex + '\n'; + output += inner + 'actual: ' + ac + '\n'; + } + } + if (res.at) { + output += inner + 'at: ' + res.at + '\n'; + } + if (res.operator === 'error' && res.actual && res.actual.stack) { + var lines = String(res.actual.stack).split('\n'); + output += inner + 'stack: |-\n'; + for (var i = 0; i < lines.length; i++) { + output += inner + ' ' + lines[i] + '\n'; + } + } + + output += outer + '...\n'; + return output; +} + +function getNextTest (results) { + if (!results._only) { + return results.tests.shift(); + } + + do { + var t = results.tests.shift(); + if (!t) continue; + if (results._only === t.name) { + return t; + } + } while (results.tests.length !== 0) +} + +function invalidYaml (str) { + return regexpTest(yamlIndicators, str); +} + +}).call(this,require('_process')) +},{"_process":84,"events":80,"function-bind":62,"has":63,"inherits":64,"object-inspect":65,"resumer":66,"through":67}],57:[function(require,module,exports){ +(function (process,__dirname){ +var deepEqual = require('deep-equal'); +var defined = require('defined'); +var path = require('path'); +var inherits = require('inherits'); +var EventEmitter = require('events').EventEmitter; +var has = require('has'); + +module.exports = Test; + +var nextTick = typeof setImmediate !== 'undefined' + ? setImmediate + : process.nextTick +; + +inherits(Test, EventEmitter); + +var getTestArgs = function (name_, opts_, cb_) { + var name = '(anonymous)'; + var opts = {}; + var cb; + + for (var i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + var t = typeof arg; + if (t === 'string') { + name = arg; + } + else if (t === 'object') { + opts = arg || opts; + } + else if (t === 'function') { + cb = arg; + } + } + return { name: name, opts: opts, cb: cb }; +}; + +function Test (name_, opts_, cb_) { + if (! (this instanceof Test)) { + return new Test(name_, opts_, cb_); + } + + var args = getTestArgs(name_, opts_, cb_); + + this.readable = true; + this.name = args.name || '(anonymous)'; + this.assertCount = 0; + this.pendingCount = 0; + this._skip = args.opts.skip || false; + this._plan = undefined; + this._cb = args.cb; + this._progeny = []; + this._ok = true; + + if (args.opts.timeout !== undefined) { + this.timeoutAfter(args.opts.timeout); + } + + for (var prop in this) { + this[prop] = (function bind(self, val) { + if (typeof val === 'function') { + return function bound() { + return val.apply(self, arguments); + }; + } + else return val; + })(this, this[prop]); + } +} + +Test.prototype.run = function () { + if (!this._cb || this._skip) { + return this._end(); + } + this.emit('prerun'); + this._cb(this); + this.emit('run'); +}; + +Test.prototype.test = function (name, opts, cb) { + var self = this; + var t = new Test(name, opts, cb); + this._progeny.push(t); + this.pendingCount++; + this.emit('test', t); + t.on('prerun', function () { + self.assertCount++; + }) + + if (!self._pendingAsserts()) { + nextTick(function () { + self._end(); + }); + } + + nextTick(function() { + if (!self._plan && self.pendingCount == self._progeny.length) { + self._end(); + } + }); +}; + +Test.prototype.comment = function (msg) { + this.emit('result', msg.trim().replace(/^#\s*/, '')); +}; + +Test.prototype.plan = function (n) { + this._plan = n; + this.emit('plan', n); +}; + +Test.prototype.timeoutAfter = function(ms) { + if (!ms) throw new Error('timeoutAfter requires a timespan'); + var self = this; + var timeout = setTimeout(function() { + self.fail('test timed out after ' + ms + 'ms'); + self.end(); + }, ms); + this.once('end', function() { + clearTimeout(timeout); + }); +} + +Test.prototype.end = function (err) { + var self = this; + if (arguments.length >= 1 && !!err) { + this.ifError(err); + } + + if (this.calledEnd) { + this.fail('.end() called twice'); + } + this.calledEnd = true; + this._end(); +}; + +Test.prototype._end = function (err) { + var self = this; + if (this._progeny.length) { + var t = this._progeny.shift(); + t.on('end', function () { self._end() }); + t.run(); + return; + } + + if (!this.ended) this.emit('end'); + var pendingAsserts = this._pendingAsserts(); + if (!this._planError && this._plan !== undefined && pendingAsserts) { + this._planError = true; + this.fail('plan != count', { + expected : this._plan, + actual : this.assertCount + }); + } + this.ended = true; +}; + +Test.prototype._exit = function () { + if (this._plan !== undefined && + !this._planError && this.assertCount !== this._plan) { + this._planError = true; + this.fail('plan != count', { + expected : this._plan, + actual : this.assertCount, + exiting : true + }); + } + else if (!this.ended) { + this.fail('test exited without ending', { + exiting: true + }); + } +}; + +Test.prototype._pendingAsserts = function () { + if (this._plan === undefined) { + return 1; + } + else { + return this._plan - (this._progeny.length + this.assertCount); + } +}; + +Test.prototype._assert = function assert (ok, opts) { + var self = this; + var extra = opts.extra || {}; + + var res = { + id : self.assertCount ++, + ok : Boolean(ok), + skip : defined(extra.skip, opts.skip), + name : defined(extra.message, opts.message, '(unnamed assert)'), + operator : defined(extra.operator, opts.operator) + }; + if (has(opts, 'actual') || has(extra, 'actual')) { + res.actual = defined(extra.actual, opts.actual); + } + if (has(opts, 'expected') || has(extra, 'expected')) { + res.expected = defined(extra.expected, opts.expected); + } + this._ok = Boolean(this._ok && ok); + + if (!ok) { + res.error = defined(extra.error, opts.error, new Error(res.name)); + } + + if (!ok) { + var e = new Error('exception'); + var err = (e.stack || '').split('\n'); + var dir = path.dirname(__dirname) + '/'; + + for (var i = 0; i < err.length; i++) { + var m = /^[^\s]*\s*\bat\s+(.+)/.exec(err[i]); + if (!m) { + continue; + } + + var s = m[1].split(/\s+/); + var filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[1]); + if (!filem) { + filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[2]); + + if (!filem) { + filem = /(\/[^:\s]+:(\d+)(?::(\d+))?)/.exec(s[3]); + + if (!filem) { + continue; + } + } + } + + if (filem[1].slice(0, dir.length) === dir) { + continue; + } + + res.functionName = s[0]; + res.file = filem[1]; + res.line = Number(filem[2]); + if (filem[3]) res.column = filem[3]; + + res.at = m[1]; + break; + } + } + + self.emit('result', res); + + var pendingAsserts = self._pendingAsserts(); + if (!pendingAsserts) { + if (extra.exiting) { + self._end(); + } else { + nextTick(function () { + self._end(); + }); + } + } + + if (!self._planError && pendingAsserts < 0) { + self._planError = true; + self.fail('plan != count', { + expected : self._plan, + actual : self._plan - pendingAsserts + }); + } +}; + +Test.prototype.fail = function (msg, extra) { + this._assert(false, { + message : msg, + operator : 'fail', + extra : extra + }); +}; + +Test.prototype.pass = function (msg, extra) { + this._assert(true, { + message : msg, + operator : 'pass', + extra : extra + }); +}; + +Test.prototype.skip = function (msg, extra) { + this._assert(true, { + message : msg, + operator : 'skip', + skip : true, + extra : extra + }); +}; + +Test.prototype.ok += Test.prototype['true'] += Test.prototype.assert += function (value, msg, extra) { + this._assert(value, { + message : msg, + operator : 'ok', + expected : true, + actual : value, + extra : extra + }); +}; + +Test.prototype.notOk += Test.prototype['false'] += Test.prototype.notok += function (value, msg, extra) { + this._assert(!value, { + message : msg, + operator : 'notOk', + expected : false, + actual : value, + extra : extra + }); +}; + +Test.prototype.error += Test.prototype.ifError += Test.prototype.ifErr += Test.prototype.iferror += function (err, msg, extra) { + this._assert(!err, { + message : defined(msg, String(err)), + operator : 'error', + actual : err, + extra : extra + }); +}; + +Test.prototype.equal += Test.prototype.equals += Test.prototype.isEqual += Test.prototype.is += Test.prototype.strictEqual += Test.prototype.strictEquals += function (a, b, msg, extra) { + this._assert(a === b, { + message : defined(msg, 'should be equal'), + operator : 'equal', + actual : a, + expected : b, + extra : extra + }); +}; + +Test.prototype.notEqual += Test.prototype.notEquals += Test.prototype.notStrictEqual += Test.prototype.notStrictEquals += Test.prototype.isNotEqual += Test.prototype.isNot += Test.prototype.not += Test.prototype.doesNotEqual += Test.prototype.isInequal += function (a, b, msg, extra) { + this._assert(a !== b, { + message : defined(msg, 'should not be equal'), + operator : 'notEqual', + actual : a, + notExpected : b, + extra : extra + }); +}; + +Test.prototype.deepEqual += Test.prototype.deepEquals += Test.prototype.isEquivalent += Test.prototype.same += function (a, b, msg, extra) { + this._assert(deepEqual(a, b, { strict: true }), { + message : defined(msg, 'should be equivalent'), + operator : 'deepEqual', + actual : a, + expected : b, + extra : extra + }); +}; + +Test.prototype.deepLooseEqual += Test.prototype.looseEqual += Test.prototype.looseEquals += function (a, b, msg, extra) { + this._assert(deepEqual(a, b), { + message : defined(msg, 'should be equivalent'), + operator : 'deepLooseEqual', + actual : a, + expected : b, + extra : extra + }); +}; + +Test.prototype.notDeepEqual += Test.prototype.notEquivalent += Test.prototype.notDeeply += Test.prototype.notSame += Test.prototype.isNotDeepEqual += Test.prototype.isNotDeeply += Test.prototype.isNotEquivalent += Test.prototype.isInequivalent += function (a, b, msg, extra) { + this._assert(!deepEqual(a, b, { strict: true }), { + message : defined(msg, 'should not be equivalent'), + operator : 'notDeepEqual', + actual : a, + notExpected : b, + extra : extra + }); +}; + +Test.prototype.notDeepLooseEqual += Test.prototype.notLooseEqual += Test.prototype.notLooseEquals += function (a, b, msg, extra) { + this._assert(!deepEqual(a, b), { + message : defined(msg, 'should be equivalent'), + operator : 'notDeepLooseEqual', + actual : a, + expected : b, + extra : extra + }); +}; + +Test.prototype['throws'] = function (fn, expected, msg, extra) { + if (typeof expected === 'string') { + msg = expected; + expected = undefined; + } + + var caught = undefined; + + try { + fn(); + } catch (err) { + caught = { error : err }; + var message = err.message; + delete err.message; + err.message = message; + } + + var passed = caught; + + if (expected instanceof RegExp) { + passed = expected.test(caught && caught.error); + expected = String(expected); + } + + if (typeof expected === 'function' && caught) { + passed = caught.error instanceof expected; + caught.error = caught.error.constructor; + } + + this._assert(passed, { + message : defined(msg, 'should throw'), + operator : 'throws', + actual : caught && caught.error, + expected : expected, + error: !passed && caught && caught.error, + extra : extra + }); +}; + +Test.prototype.doesNotThrow = function (fn, expected, msg, extra) { + if (typeof expected === 'string') { + msg = expected; + expected = undefined; + } + var caught = undefined; + try { + fn(); + } + catch (err) { + caught = { error : err }; + } + this._assert(!caught, { + message : defined(msg, 'should not throw'), + operator : 'throws', + actual : caught && caught.error, + expected : expected, + error : caught && caught.error, + extra : extra + }); +}; + +Test.skip = function (name_, _opts, _cb) { + var args = getTestArgs.apply(null, arguments); + args.opts.skip = true; + return Test(args.name, args.opts, args.cb); +}; + +// vim: set softtabstop=4 shiftwidth=4: + + +}).call(this,require('_process'),"/node_modules/tape/lib") +},{"_process":84,"deep-equal":58,"defined":61,"events":80,"has":63,"inherits":64,"path":83}],58:[function(require,module,exports){ +var pSlice = Array.prototype.slice; +var objectKeys = require('./lib/keys.js'); +var isArguments = require('./lib/is_arguments.js'); + +var deepEqual = module.exports = function (actual, expected, opts) { + if (!opts) opts = {}; + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + + } else if (actual instanceof Date && expected instanceof Date) { + return actual.getTime() === expected.getTime(); + + // 7.3. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if (typeof actual != 'object' && typeof expected != 'object') { + return opts.strict ? actual === expected : actual == expected; + + // 7.4. For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else { + return objEquiv(actual, expected, opts); + } +} + +function isUndefinedOrNull(value) { + return value === null || value === undefined; +} + +function isBuffer (x) { + if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false; + if (typeof x.copy !== 'function' || typeof x.slice !== 'function') { + return false; + } + if (x.length > 0 && typeof x[0] !== 'number') return false; + return true; +} + +function objEquiv(a, b, opts) { + var i, key; + if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) + return false; + // an identical 'prototype' property. + if (a.prototype !== b.prototype) return false; + //~~~I've managed to break Object.keys through screwy arguments passing. + // Converting to array solves the problem. + if (isArguments(a)) { + if (!isArguments(b)) { + return false; + } + a = pSlice.call(a); + b = pSlice.call(b); + return deepEqual(a, b, opts); + } + if (isBuffer(a)) { + if (!isBuffer(b)) { + return false; + } + if (a.length !== b.length) return false; + for (i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false; + } + return true; + } + try { + var ka = objectKeys(a), + kb = objectKeys(b); + } catch (e) {//happens when one is a string literal and the other isn't + return false; + } + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length != kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] != kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!deepEqual(a[key], b[key], opts)) return false; + } + return typeof a === typeof b; +} + +},{"./lib/is_arguments.js":59,"./lib/keys.js":60}],59:[function(require,module,exports){ +var supportsArgumentsClass = (function(){ + return Object.prototype.toString.call(arguments) +})() == '[object Arguments]'; + +exports = module.exports = supportsArgumentsClass ? supported : unsupported; + +exports.supported = supported; +function supported(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +}; + +exports.unsupported = unsupported; +function unsupported(object){ + return object && + typeof object == 'object' && + typeof object.length == 'number' && + Object.prototype.hasOwnProperty.call(object, 'callee') && + !Object.prototype.propertyIsEnumerable.call(object, 'callee') || + false; +}; + +},{}],60:[function(require,module,exports){ +exports = module.exports = typeof Object.keys === 'function' + ? Object.keys : shim; + +exports.shim = shim; +function shim (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} + +},{}],61:[function(require,module,exports){ +module.exports = function () { + for (var i = 0; i < arguments.length; i++) { + if (arguments[i] !== undefined) return arguments[i]; + } +}; + +},{}],62:[function(require,module,exports){ +var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; +var slice = Array.prototype.slice; +var toStr = Object.prototype.toString; +var funcType = '[object Function]'; + +module.exports = function bind(that) { + var target = this; + if (typeof target !== 'function' || toStr.call(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slice.call(arguments, 1); + + var binder = function () { + if (this instanceof bound) { + var result = target.apply( + this, + args.concat(slice.call(arguments)) + ); + if (Object(result) === result) { + return result; + } + return this; + } else { + return target.apply( + that, + args.concat(slice.call(arguments)) + ); + } + }; + + var boundLength = Math.max(0, target.length - args.length); + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + boundArgs.push('$' + i); + } + + var bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder); + + if (target.prototype) { + var Empty = function Empty() {}; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + + return bound; +}; + + +},{}],63:[function(require,module,exports){ +var bind = require('function-bind'); + +module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); + +},{"function-bind":62}],64:[function(require,module,exports){ +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } +} + +},{}],65:[function(require,module,exports){ +module.exports = function inspect_ (obj, opts, depth, seen) { + if (!opts) opts = {}; + + var maxDepth = opts.depth === undefined ? 5 : opts.depth; + if (depth === undefined) depth = 0; + if (depth >= maxDepth && maxDepth > 0 + && obj && typeof obj === 'object') { + return '[Object]'; + } + + if (seen === undefined) seen = []; + else if (indexOf(seen, obj) >= 0) { + return '[Circular]'; + } + + function inspect (value, from) { + if (from) { + seen = seen.slice(); + seen.push(from); + } + return inspect_(value, opts, depth + 1, seen); + } + + if (typeof obj === 'string') { + return inspectString(obj); + } + else if (typeof obj === 'function') { + var name = nameOf(obj); + return '[Function' + (name ? ': ' + name : '') + ']'; + } + else if (obj === null) { + return 'null'; + } + else if (isSymbol(obj)) { + var symString = Symbol.prototype.toString.call(obj); + return typeof obj === 'object' ? 'Object(' + symString + ')' : symString; + } + else if (isElement(obj)) { + var s = '<' + String(obj.nodeName).toLowerCase(); + var attrs = obj.attributes || []; + for (var i = 0; i < attrs.length; i++) { + s += ' ' + attrs[i].name + '="' + quote(attrs[i].value) + '"'; + } + s += '>'; + if (obj.childNodes && obj.childNodes.length) s += '...'; + s += ''; + return s; + } + else if (isArray(obj)) { + if (obj.length === 0) return '[]'; + var xs = Array(obj.length); + for (var i = 0; i < obj.length; i++) { + xs[i] = has(obj, i) ? inspect(obj[i], obj) : ''; + } + return '[ ' + xs.join(', ') + ' ]'; + } + else if (isError(obj)) { + var parts = []; + for (var key in obj) { + if (!has(obj, key)) continue; + + if (/[^\w$]/.test(key)) { + parts.push(inspect(key) + ': ' + inspect(obj[key])); + } + else { + parts.push(key + ': ' + inspect(obj[key])); + } + } + if (parts.length === 0) return '[' + obj + ']'; + return '{ [' + obj + '] ' + parts.join(', ') + ' }'; + } + else if (typeof obj === 'object' && typeof obj.inspect === 'function') { + return obj.inspect(); + } + else if (typeof obj === 'object' && !isDate(obj) && !isRegExp(obj)) { + var xs = [], keys = []; + for (var key in obj) { + if (has(obj, key)) keys.push(key); + } + keys.sort(); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (/[^\w$]/.test(key)) { + xs.push(inspect(key) + ': ' + inspect(obj[key], obj)); + } + else xs.push(key + ': ' + inspect(obj[key], obj)); + } + if (xs.length === 0) return '{}'; + return '{ ' + xs.join(', ') + ' }'; + } + else return String(obj); +}; + +function quote (s) { + return String(s).replace(/"/g, '"'); +} + +function isArray (obj) { return toStr(obj) === '[object Array]' } +function isDate (obj) { return toStr(obj) === '[object Date]' } +function isRegExp (obj) { return toStr(obj) === '[object RegExp]' } +function isError (obj) { return toStr(obj) === '[object Error]' } +function isSymbol (obj) { return toStr(obj) === '[object Symbol]' } + +var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; }; +function has (obj, key) { + return hasOwn.call(obj, key); +} + +function toStr (obj) { + return Object.prototype.toString.call(obj); +} + +function nameOf (f) { + if (f.name) return f.name; + var m = f.toString().match(/^function\s*([\w$]+)/); + if (m) return m[1]; +} + +function indexOf (xs, x) { + if (xs.indexOf) return xs.indexOf(x); + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} + +function isElement (x) { + if (!x || typeof x !== 'object') return false; + if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) { + return true; + } + return typeof x.nodeName === 'string' + && typeof x.getAttribute === 'function' + ; +} + +function inspectString (str) { + var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte); + return "'" + s + "'"; + + function lowbyte (c) { + var n = c.charCodeAt(0); + var x = { 8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r' }[n]; + if (x) return '\\' + x; + return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16); + } +} + +},{}],66:[function(require,module,exports){ +(function (process){ +var through = require('through'); +var nextTick = typeof setImmediate !== 'undefined' + ? setImmediate + : process.nextTick +; + +module.exports = function (write, end) { + var tr = through(write, end); + tr.pause(); + var resume = tr.resume; + var pause = tr.pause; + var paused = false; + + tr.pause = function () { + paused = true; + return pause.apply(this, arguments); + }; + + tr.resume = function () { + paused = false; + return resume.apply(this, arguments); + }; + + nextTick(function () { + if (!paused) tr.resume(); + }); + + return tr; +}; + +}).call(this,require('_process')) +},{"_process":84,"through":67}],67:[function(require,module,exports){ +(function (process){ +var Stream = require('stream') + +// through +// +// a stream that does nothing but re-emit the input. +// useful for aggregating a series of changing but not ending streams into one stream) + +exports = module.exports = through +through.through = through + +//create a readable writable stream. + +function through (write, end, opts) { + write = write || function (data) { this.queue(data) } + end = end || function () { this.queue(null) } + + var ended = false, destroyed = false, buffer = [], _ended = false + var stream = new Stream() + stream.readable = stream.writable = true + stream.paused = false + +// stream.autoPause = !(opts && opts.autoPause === false) + stream.autoDestroy = !(opts && opts.autoDestroy === false) + + stream.write = function (data) { + write.call(this, data) + return !stream.paused + } + + function drain() { + while(buffer.length && !stream.paused) { + var data = buffer.shift() + if(null === data) + return stream.emit('end') + else + stream.emit('data', data) + } + } + + stream.queue = stream.push = function (data) { +// console.error(ended) + if(_ended) return stream + if(data === null) _ended = true + buffer.push(data) + drain() + return stream + } + + //this will be registered as the first 'end' listener + //must call destroy next tick, to make sure we're after any + //stream piped from here. + //this is only a problem if end is not emitted synchronously. + //a nicer way to do this is to make sure this is the last listener for 'end' + + stream.on('end', function () { + stream.readable = false + if(!stream.writable && stream.autoDestroy) + process.nextTick(function () { + stream.destroy() + }) + }) + + function _end () { + stream.writable = false + end.call(stream) + if(!stream.readable && stream.autoDestroy) + stream.destroy() + } + + stream.end = function (data) { + if(ended) return + ended = true + if(arguments.length) stream.write(data) + _end() // will emit or queue + return stream + } + + stream.destroy = function () { + if(destroyed) return + destroyed = true + ended = true + buffer.length = 0 + stream.writable = stream.readable = false + stream.emit('close') + return stream + } + + stream.pause = function () { + if(stream.paused) return + stream.paused = true + return stream + } + + stream.resume = function () { + if(stream.paused) { + stream.paused = false + stream.emit('resume') + } + drain() + //may have become paused again, + //as drain emits 'data'. + if(!stream.paused) + stream.emit('drain') + return stream + } + return stream +} + + +}).call(this,require('_process')) +},{"_process":84,"stream":96}],68:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Wraps a function of any arity (including nullary) in a function that accepts exactly `n` + * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function, + * functions produced by `arity` will pass all provided arguments to the wrapped function. + * + * @func + * @memberOf R + * @sig (Number, (* -> *)) -> (* -> *) + * @category Function + * @param {Number} n The desired arity of the returned function. + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is + * guaranteed to be of arity `n`. + * @deprecated since v0.15.0 + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.arity(1, takesTwoArgs); + * takesOneArg.length; //=> 1 + * // All arguments are passed through to the wrapped function + * takesOneArg(1, 2); //=> [1, 2] + */ +module.exports = _curry2(function(n, fn) { + // jshint unused:vars + switch (n) { + case 0: return function() {return fn.apply(this, arguments);}; + case 1: return function(a0) {return fn.apply(this, arguments);}; + case 2: return function(a0, a1) {return fn.apply(this, arguments);}; + case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);}; + case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);}; + case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);}; + case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);}; + case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);}; + case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);}; + case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);}; + case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);}; + default: throw new Error('First argument to arity must be a non-negative integer no greater than ten'); + } +}); + +},{"./internal/_curry2":71}],69:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _curryN = require('./internal/_curryN'); +var arity = require('./arity'); + + +/** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry2(function curryN(length, fn) { + return arity(length, _curryN(length, [], fn)); +}); + +},{"./arity":68,"./internal/_curry2":71,"./internal/_curryN":72}],70:[function(require,module,exports){ +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn(a); + } + }; +}; + +},{}],71:[function(require,module,exports){ +arguments[4][24][0].apply(exports,arguments) +},{"./_curry1":70,"dup":24}],72:[function(require,module,exports){ +var arity = require('../arity'); + + +/** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ +module.exports = function _curryN(length, received, fn) { + return function() { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && + (received[combinedIdx] == null || + received[combinedIdx]['@@functional/placeholder'] !== true || + argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn)); + }; +}; + +},{"../arity":68}],73:[function(require,module,exports){ +var curryN = require('ramda/src/curryN'); + +function isString(s) { return typeof s === 'string'; } +function isNumber(n) { return typeof n === 'number'; } +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} +function isFunction(f) { return typeof f === 'function'; } +var isArray = Array.isArray || function(a) { return 'length' in a; }; + +var mapConstrToFn = curryN(2, function(group, constr) { + return constr === String ? isString + : constr === Number ? isNumber + : constr === Object ? isObject + : constr === Array ? isArray + : constr === Function ? isFunction + : constr === undefined ? group + : constr; +}); + +function Constructor(group, name, validators) { + validators = validators.map(mapConstrToFn(group)); + var constructor = curryN(validators.length, function() { + var val = [], v, validator; + for (var i = 0; i < arguments.length; ++i) { + v = arguments[i]; + validator = validators[i]; + if ((typeof validator === 'function' && validator(v)) || + (v !== undefined && v !== null && v.of === validator)) { + val[i] = arguments[i]; + } else { + throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name); + } + } + val.of = group; + val.name = name; + return val; + }); + return constructor; +} + +function rawCase(type, cases, action, arg) { + if (type !== action.of) throw new TypeError('wrong type passed to case'); + var name = action.name in cases ? action.name + : '_' in cases ? '_' + : undefined; + if (name === undefined) { + throw new Error('unhandled value passed to case'); + } else { + return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action); + } +} + +var typeCase = curryN(3, rawCase); +var caseOn = curryN(4, rawCase); + +function Type(desc) { + var obj = {}; + for (var key in desc) { + obj[key] = Constructor(obj, key, desc[key]); + } + obj.case = typeCase(obj); + obj.caseOn = caseOn(obj); + return obj; +} + +module.exports = Type; + +},{"ramda/src/curryN":69}],74:[function(require,module,exports){ + +},{}],75:[function(require,module,exports){ +arguments[4][74][0].apply(exports,arguments) +},{"dup":74}],76:[function(require,module,exports){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('is-array') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 +Buffer.poolSize = 8192 // not used by this implementation + +var kMaxLength = 0x3fffffff +var rootParent = {} + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Note: + * + * - Implementation must support adding new properties to `Uint8Array` instances. + * Firefox 4-29 lacked support, fixed in Firefox 30+. + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + * + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will + * get the Object implementation, which is slower but will work correctly. + */ +Buffer.TYPED_ARRAY_SUPPORT = (function () { + try { + var buf = new ArrayBuffer(0) + var arr = new Uint8Array(buf) + arr.foo = function () { return 42 } + return arr.foo() === 42 && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } +})() + +/** + * Class: Buffer + * ============= + * + * The Buffer constructor returns instances of `Uint8Array` that are augmented + * with function properties for all the node `Buffer` API functions. We use + * `Uint8Array` so that square bracket notation works as expected -- it returns + * a single octet. + * + * By augmenting the instances, we can avoid modifying the `Uint8Array` + * prototype. + */ +function Buffer (arg) { + if (!(this instanceof Buffer)) { + // Avoid going through an ArgumentsAdaptorTrampoline in the common case. + if (arguments.length > 1) return new Buffer(arg, arguments[1]) + return new Buffer(arg) + } + + this.length = 0 + this.parent = undefined + + // Common case. + if (typeof arg === 'number') { + return fromNumber(this, arg) + } + + // Slightly less common case. + if (typeof arg === 'string') { + return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') + } + + // Unusual. + return fromObject(this, arg) +} + +function fromNumber (that, length) { + that = allocate(that, length < 0 ? 0 : checked(length) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < length; i++) { + that[i] = 0 + } + } + return that +} + +function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' + + // Assumption: byteLength() return value is always < kMaxLength. + var length = byteLength(string, encoding) | 0 + that = allocate(that, length) + + that.write(string, encoding) + return that +} + +function fromObject (that, object) { + if (Buffer.isBuffer(object)) return fromBuffer(that, object) + + if (isArray(object)) return fromArray(that, object) + + if (object == null) { + throw new TypeError('must start with number, buffer, array or string') + } + + if (typeof ArrayBuffer !== 'undefined' && object.buffer instanceof ArrayBuffer) { + return fromTypedArray(that, object) + } + + if (object.length) return fromArrayLike(that, object) + + return fromJsonObject(that, object) +} + +function fromBuffer (that, buffer) { + var length = checked(buffer.length) | 0 + that = allocate(that, length) + buffer.copy(that, 0, 0, length) + return that +} + +function fromArray (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +// Duplicate of fromArray() to keep fromArray() monomorphic. +function fromTypedArray (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + // Truncating the elements is probably not what people expect from typed + // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior + // of the old Buffer constructor. + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +function fromArrayLike (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. +// Returns a zero-length buffer for inputs that don't conform to the spec. +function fromJsonObject (that, object) { + var array + var length = 0 + + if (object.type === 'Buffer' && isArray(object.data)) { + array = object.data + length = checked(array.length) | 0 + } + that = allocate(that, length) + + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +function allocate (that, length) { + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = Buffer._augment(new Uint8Array(length)) + } else { + // Fallback: Return an object instance of the Buffer class + that.length = length + that._isBuffer = true + } + + var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 + if (fromPool) that.parent = rootParent + + return that +} + +function checked (length) { + // Note: cannot use `length < kMaxLength` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength.toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (subject, encoding) { + if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) + + var buf = new Buffer(subject, encoding) + delete buf.parent + return buf +} + +Buffer.isBuffer = function isBuffer (b) { + return !!(b != null && b._isBuffer) +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + var i = 0 + var len = Math.min(x, y) + while (i < len) { + if (a[i] !== b[i]) break + + ++i + } + + if (i !== len) { + x = a[i] + y = b[i] + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 +} + +Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'binary': + case 'base64': + case 'raw': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') + + if (list.length === 0) { + return new Buffer(0) + } else if (list.length === 1) { + return list[0] + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; i++) { + length += list[i].length + } + } + + var buf = new Buffer(length) + var pos = 0 + for (i = 0; i < list.length; i++) { + var item = list[i] + item.copy(buf, pos) + pos += item.length + } + return buf +} + +function byteLength (string, encoding) { + if (typeof string !== 'string') string = String(string) + + if (string.length === 0) return 0 + + switch (encoding || 'utf8') { + case 'ascii': + case 'binary': + case 'raw': + return string.length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return string.length * 2 + case 'hex': + return string.length >>> 1 + case 'utf8': + case 'utf-8': + return utf8ToBytes(string).length + case 'base64': + return base64ToBytes(string).length + default: + return string.length + } +} +Buffer.byteLength = byteLength + +// pre-set for values that may exist in the future +Buffer.prototype.length = undefined +Buffer.prototype.parent = undefined + +// toString(encoding, start=0, end=buffer.length) +Buffer.prototype.toString = function toString (encoding, start, end) { + var loweredCase = false + + start = start | 0 + end = end === undefined || end === Infinity ? this.length : end | 0 + + if (!encoding) encoding = 'utf8' + if (start < 0) start = 0 + if (end > this.length) end = this.length + if (end <= start) return '' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'binary': + return binarySlice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 +} + +Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function compare (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return 0 + return Buffer.compare(this, b) +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset) { + if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff + else if (byteOffset < -0x80000000) byteOffset = -0x80000000 + byteOffset >>= 0 + + if (this.length === 0) return -1 + if (byteOffset >= this.length) return -1 + + // Negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) + + if (typeof val === 'string') { + if (val.length === 0) return -1 // special case: looking for empty string always fails + return String.prototype.indexOf.call(this, val, byteOffset) + } + if (Buffer.isBuffer(val)) { + return arrayIndexOf(this, val, byteOffset) + } + if (typeof val === 'number') { + if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { + return Uint8Array.prototype.indexOf.call(this, val, byteOffset) + } + return arrayIndexOf(this, [ val ], byteOffset) + } + + function arrayIndexOf (arr, val, byteOffset) { + var foundIndex = -1 + for (var i = 0; byteOffset + i < arr.length; i++) { + if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex + } else { + foundIndex = -1 + } + } + return -1 + } + + throw new TypeError('val must be string, number or Buffer') +} + +// `get` will be removed in Node 0.13+ +Buffer.prototype.get = function get (offset) { + console.log('.get() is deprecated. Access using array indexes instead.') + return this.readUInt8(offset) +} + +// `set` will be removed in Node 0.13+ +Buffer.prototype.set = function set (v, offset) { + console.log('.set() is deprecated. Access using array indexes instead.') + return this.writeUInt8(v, offset) +} + +function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new Error('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; i++) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(parsed)) throw new Error('Invalid hex string') + buf[offset + i] = parsed + } + return i +} + +function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) +} + +function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) +} + +function binaryWrite (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) +} + +function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) +} + +function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) +} + +Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset | 0 + if (isFinite(length)) { + length = length | 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + var swap = encoding + encoding = offset + offset = length | 0 + length = swap + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'binary': + return binaryWrite(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} + +Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } +} + +function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } +} + +function utf8Slice (buf, start, end) { + var res = '' + var tmp = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; i++) { + if (buf[i] <= 0x7F) { + res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]) + tmp = '' + } else { + tmp += '%' + buf[i].toString(16) + } + } + + return res + decodeUtf8Char(tmp) +} + +function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; i++) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret +} + +function binarySlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; i++) { + ret += String.fromCharCode(buf[i]) + } + return ret +} + +function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; i++) { + out += toHex(buf[i]) + } + return out +} + +function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) + } + return res +} + +Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = Buffer._augment(this.subarray(start, end)) + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; i++) { + newBuf[i] = this[i + start] + } + } + + if (newBuf.length) newBuf.parent = this.parent || this + + return newBuf +} + +/* + * Need to make sure that buffer isn't trying to write out of bounds. + */ +function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') +} + +Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val +} + +Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val +} + +Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) +} + +Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) +} + +Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val +} + +Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) +} + +Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val +} + +Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) +} + +Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) +} + +Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) +} + +function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') + if (value > max || value < min) throw new RangeError('value is out of bounds') + if (offset + ext > buf.length) throw new RangeError('index out of range') +} + +Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = value + return offset + 1 +} + +function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = value + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = value + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = value + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = value < 0 ? 1 : 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = value < 0 ? 1 : 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength +} + +Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + if (value < 0) value = 0xff + value + 1 + this[offset] = value + return offset + 1 +} + +Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 +} + +Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = value + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = value + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 +} + +Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = value + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (value > max || value < min) throw new RangeError('value is out of bounds') + if (offset + ext > buf.length) throw new RangeError('index out of range') + if (offset < 0) throw new RangeError('index out of range') +} + +function writeFloat (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 +} + +Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) +} + +function writeDouble (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 +} + +Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) +} + +Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) +} + +// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) +Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + + if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < len; i++) { + target[i + targetStart] = this[i + start] + } + } else { + target._set(this.subarray(start, start + len), targetStart) + } + + return len +} + +// fill(value, start=0, end=buffer.length) +Buffer.prototype.fill = function fill (value, start, end) { + if (!value) value = 0 + if (!start) start = 0 + if (!end) end = this.length + + if (end < start) throw new RangeError('end < start') + + // Fill 0 bytes; we're done + if (end === start) return + if (this.length === 0) return + + if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') + if (end < 0 || end > this.length) throw new RangeError('end out of bounds') + + var i + if (typeof value === 'number') { + for (i = start; i < end; i++) { + this[i] = value + } + } else { + var bytes = utf8ToBytes(value.toString()) + var len = bytes.length + for (i = start; i < end; i++) { + this[i] = bytes[i % len] + } + } + + return this +} + +/** + * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. + * Added in Node 0.12. Only available in browsers that support ArrayBuffer. + */ +Buffer.prototype.toArrayBuffer = function toArrayBuffer () { + if (typeof Uint8Array !== 'undefined') { + if (Buffer.TYPED_ARRAY_SUPPORT) { + return (new Buffer(this)).buffer + } else { + var buf = new Uint8Array(this.length) + for (var i = 0, len = buf.length; i < len; i += 1) { + buf[i] = this[i] + } + return buf.buffer + } + } else { + throw new TypeError('Buffer.toArrayBuffer not supported in this browser') + } +} + +// HELPER FUNCTIONS +// ================ + +var BP = Buffer.prototype + +/** + * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods + */ +Buffer._augment = function _augment (arr) { + arr.constructor = Buffer + arr._isBuffer = true + + // save reference to original Uint8Array set method before overwriting + arr._set = arr.set + + // deprecated, will be removed in node 0.13+ + arr.get = BP.get + arr.set = BP.set + + arr.write = BP.write + arr.toString = BP.toString + arr.toLocaleString = BP.toString + arr.toJSON = BP.toJSON + arr.equals = BP.equals + arr.compare = BP.compare + arr.indexOf = BP.indexOf + arr.copy = BP.copy + arr.slice = BP.slice + arr.readUIntLE = BP.readUIntLE + arr.readUIntBE = BP.readUIntBE + arr.readUInt8 = BP.readUInt8 + arr.readUInt16LE = BP.readUInt16LE + arr.readUInt16BE = BP.readUInt16BE + arr.readUInt32LE = BP.readUInt32LE + arr.readUInt32BE = BP.readUInt32BE + arr.readIntLE = BP.readIntLE + arr.readIntBE = BP.readIntBE + arr.readInt8 = BP.readInt8 + arr.readInt16LE = BP.readInt16LE + arr.readInt16BE = BP.readInt16BE + arr.readInt32LE = BP.readInt32LE + arr.readInt32BE = BP.readInt32BE + arr.readFloatLE = BP.readFloatLE + arr.readFloatBE = BP.readFloatBE + arr.readDoubleLE = BP.readDoubleLE + arr.readDoubleBE = BP.readDoubleBE + arr.writeUInt8 = BP.writeUInt8 + arr.writeUIntLE = BP.writeUIntLE + arr.writeUIntBE = BP.writeUIntBE + arr.writeUInt16LE = BP.writeUInt16LE + arr.writeUInt16BE = BP.writeUInt16BE + arr.writeUInt32LE = BP.writeUInt32LE + arr.writeUInt32BE = BP.writeUInt32BE + arr.writeIntLE = BP.writeIntLE + arr.writeIntBE = BP.writeIntBE + arr.writeInt8 = BP.writeInt8 + arr.writeInt16LE = BP.writeInt16LE + arr.writeInt16BE = BP.writeInt16BE + arr.writeInt32LE = BP.writeInt32LE + arr.writeInt32BE = BP.writeInt32BE + arr.writeFloatLE = BP.writeFloatLE + arr.writeFloatBE = BP.writeFloatBE + arr.writeDoubleLE = BP.writeDoubleLE + arr.writeDoubleBE = BP.writeDoubleBE + arr.fill = BP.fill + arr.inspect = BP.inspect + arr.toArrayBuffer = BP.toArrayBuffer + + return arr +} + +var INVALID_BASE64_RE = /[^+\/0-9A-z\-]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str +} + +function stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') +} + +function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) +} + +function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + var i = 0 + + for (; i < length; i++) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (leadSurrogate) { + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } else { + // valid surrogate pair + codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000 + leadSurrogate = null + } + } else { + // no lead yet + + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else { + // valid lead + leadSurrogate = codePoint + continue + } + } + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = null + } + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x200000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes +} + +function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; i++) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray +} + +function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; i++) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray +} + +function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) +} + +function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; i++) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i +} + +function decodeUtf8Char (str) { + try { + return decodeURIComponent(str) + } catch (err) { + return String.fromCharCode(0xFFFD) // UTF 8 invalid char + } +} + +},{"base64-js":77,"ieee754":78,"is-array":79}],77:[function(require,module,exports){ +var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + +;(function (exports) { + 'use strict'; + + var Arr = (typeof Uint8Array !== 'undefined') + ? Uint8Array + : Array + + var PLUS = '+'.charCodeAt(0) + var SLASH = '/'.charCodeAt(0) + var NUMBER = '0'.charCodeAt(0) + var LOWER = 'a'.charCodeAt(0) + var UPPER = 'A'.charCodeAt(0) + var PLUS_URL_SAFE = '-'.charCodeAt(0) + var SLASH_URL_SAFE = '_'.charCodeAt(0) + + function decode (elt) { + var code = elt.charCodeAt(0) + if (code === PLUS || + code === PLUS_URL_SAFE) + return 62 // '+' + if (code === SLASH || + code === SLASH_URL_SAFE) + return 63 // '/' + if (code < NUMBER) + return -1 //no match + if (code < NUMBER + 10) + return code - NUMBER + 26 + 26 + if (code < UPPER + 26) + return code - UPPER + if (code < LOWER + 26) + return code - LOWER + 26 + } + + function b64ToByteArray (b64) { + var i, j, l, tmp, placeHolders, arr + + if (b64.length % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + var len = b64.length + placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 + + // base64 is 4/3 + up to two characters of the original data + arr = new Arr(b64.length * 3 / 4 - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? b64.length - 4 : b64.length + + var L = 0 + + function push (v) { + arr[L++] = v + } + + for (i = 0, j = 0; i < l; i += 4, j += 3) { + tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) + push((tmp & 0xFF0000) >> 16) + push((tmp & 0xFF00) >> 8) + push(tmp & 0xFF) + } + + if (placeHolders === 2) { + tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) + push(tmp & 0xFF) + } else if (placeHolders === 1) { + tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) + push((tmp >> 8) & 0xFF) + push(tmp & 0xFF) + } + + return arr + } + + function uint8ToBase64 (uint8) { + var i, + extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes + output = "", + temp, length + + function encode (num) { + return lookup.charAt(num) + } + + function tripletToBase64 (num) { + return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) + } + + // go through the array every three bytes, we'll deal with trailing stuff later + for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { + temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output += tripletToBase64(temp) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + switch (extraBytes) { + case 1: + temp = uint8[uint8.length - 1] + output += encode(temp >> 2) + output += encode((temp << 4) & 0x3F) + output += '==' + break + case 2: + temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) + output += encode(temp >> 10) + output += encode((temp >> 4) & 0x3F) + output += encode((temp << 2) & 0x3F) + output += '=' + break + } + + return output + } + + exports.toByteArray = b64ToByteArray + exports.fromByteArray = uint8ToBase64 +}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) + +},{}],78:[function(require,module,exports){ +exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) +} + +exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = nBytes * 8 - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 +} + +},{}],79:[function(require,module,exports){ + +/** + * isArray + */ + +var isArray = Array.isArray; + +/** + * toString + */ + +var str = Object.prototype.toString; + +/** + * Whether or not the given `val` + * is an array. + * + * example: + * + * isArray([]); + * // > true + * isArray(arguments); + * // > false + * isArray(''); + * // > false + * + * @param {mixed} val + * @return {bool} + */ + +module.exports = isArray || function (val) { + return !! val && '[object Array]' == str.call(val); +}; + +},{}],80:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; +} +module.exports = EventEmitter; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +EventEmitter.defaultMaxListeners = 10; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } + throw TypeError('Uncaught, unspecified "error" event.'); + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + handler.apply(this, args); + } + } else if (isObject(handler)) { + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + var m; + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.listenerCount = function(emitter, type) { + var ret; + if (!emitter._events || !emitter._events[type]) + ret = 0; + else if (isFunction(emitter._events[type])) + ret = 1; + else + ret = emitter._events[type].length; + return ret; +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}],81:[function(require,module,exports){ +arguments[4][64][0].apply(exports,arguments) +},{"dup":64}],82:[function(require,module,exports){ +module.exports = Array.isArray || function (arr) { + return Object.prototype.toString.call(arr) == '[object Array]'; +}; + +},{}],83:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; +var splitPath = function(filename) { + return splitPathRe.exec(filename).slice(1); +}; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { + var isAbsolute = exports.isAbsolute(path), + trailingSlash = substr(path, -1) === '/'; + + // Normalize the path + path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + +// posix version +exports.isAbsolute = function(path) { + return path.charAt(0) === '/'; +}; + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + if (typeof p !== 'string') { + throw new TypeError('Arguments to path.join must be strings'); + } + return p; + }).join('/')); +}; + + +// path.relative(from, to) +// posix version +exports.relative = function(from, to) { + from = exports.resolve(from).substr(1); + to = exports.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +}; + +exports.sep = '/'; +exports.delimiter = ':'; + +exports.dirname = function(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +}; + + +exports.basename = function(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPath(path)[3]; +}; + +function filter (xs, f) { + if (xs.filter) return xs.filter(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + if (f(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// String.prototype.substr - negative index don't work in IE8 +var substr = 'ab'.substr(-1) === 'b' + ? function (str, start, len) { return str.substr(start, len) } + : function (str, start, len) { + if (start < 0) start = str.length + start; + return str.substr(start, len); + } +; + +}).call(this,require('_process')) +},{"_process":84}],84:[function(require,module,exports){ +// shim for using process in browser + +var process = module.exports = {}; +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = setTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + currentQueue[queueIndex].run(); + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + clearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + setTimeout(drainQueue, 0); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +// TODO(shtylman) +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],85:[function(require,module,exports){ +module.exports = require("./lib/_stream_duplex.js") + +},{"./lib/_stream_duplex.js":86}],86:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + +module.exports = Duplex; + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} +/**/ + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); + +util.inherits(Duplex, Readable); + +forEach(objectKeys(Writable.prototype), function(method) { + if (!Duplex.prototype[method]) + Duplex.prototype[method] = Writable.prototype[method]; +}); + +function Duplex(options) { + if (!(this instanceof Duplex)) + return new Duplex(options); + + Readable.call(this, options); + Writable.call(this, options); + + if (options && options.readable === false) + this.readable = false; + + if (options && options.writable === false) + this.writable = false; + + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) + this.allowHalfOpen = false; + + this.once('end', onend); +} + +// the no-half-open enforcer +function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) + return; + + // no more data can be written. + // But allow more writes to happen in this tick. + process.nextTick(this.end.bind(this)); +} + +function forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +}).call(this,require('_process')) +},{"./_stream_readable":88,"./_stream_writable":90,"_process":84,"core-util-is":91,"inherits":81}],87:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + +module.exports = PassThrough; + +var Transform = require('./_stream_transform'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(PassThrough, Transform); + +function PassThrough(options) { + if (!(this instanceof PassThrough)) + return new PassThrough(options); + + Transform.call(this, options); +} + +PassThrough.prototype._transform = function(chunk, encoding, cb) { + cb(null, chunk); +}; + +},{"./_stream_transform":89,"core-util-is":91,"inherits":81}],88:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Readable; + +/**/ +var isArray = require('isarray'); +/**/ + + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Readable.ReadableState = ReadableState; + +var EE = require('events').EventEmitter; + +/**/ +if (!EE.listenerCount) EE.listenerCount = function(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +var Stream = require('stream'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var StringDecoder; + + +/**/ +var debug = require('util'); +if (debug && debug.debuglog) { + debug = debug.debuglog('stream'); +} else { + debug = function () {}; +} +/**/ + + +util.inherits(Readable, Stream); + +function ReadableState(options, stream) { + var Duplex = require('./_stream_duplex'); + + options = options || {}; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + var defaultHwm = options.objectMode ? 16 : 16 * 1024; + this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + this.buffer = []; + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) + this.objectMode = this.objectMode || !!options.readableObjectMode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // when piping, we only care about 'readable' events that happen + // after read()ing all the bytes and not getting any pushback. + this.ranOut = false; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) + StringDecoder = require('string_decoder/').StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + var Duplex = require('./_stream_duplex'); + + if (!(this instanceof Readable)) + return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + Stream.call(this); +} + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function(chunk, encoding) { + var state = this._readableState; + + if (util.isString(chunk) && !state.objectMode) { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = new Buffer(chunk, encoding); + encoding = ''; + } + } + + return readableAddChunk(this, state, chunk, encoding, false); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function(chunk) { + var state = this._readableState; + return readableAddChunk(this, state, chunk, '', true); +}; + +function readableAddChunk(stream, state, chunk, encoding, addToFront) { + var er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (util.isNullOrUndefined(chunk)) { + state.reading = false; + if (!state.ended) + onEofChunk(stream, state); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (state.ended && !addToFront) { + var e = new Error('stream.push() after EOF'); + stream.emit('error', e); + } else if (state.endEmitted && addToFront) { + var e = new Error('stream.unshift() after end event'); + stream.emit('error', e); + } else { + if (state.decoder && !addToFront && !encoding) + chunk = state.decoder.write(chunk); + + if (!addToFront) + state.reading = false; + + // if we want the data now, just emit it. + if (state.flowing && state.length === 0 && !state.sync) { + stream.emit('data', chunk); + stream.read(0); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) + state.buffer.unshift(chunk); + else + state.buffer.push(chunk); + + if (state.needReadable) + emitReadable(stream); + } + + maybeReadMore(stream, state); + } + } else if (!addToFront) { + state.reading = false; + } + + return needMoreData(state); +} + + + +// if it's past the high water mark, we can push in some more. +// Also, if we have no data yet, we can stand some +// more bytes. This is to work around cases where hwm=0, +// such as the repl. Also, if the push() triggered a +// readable event, and the user called read(largeNumber) such that +// needReadable was set, then we ought to push more, so that another +// 'readable' event will be triggered. +function needMoreData(state) { + return !state.ended && + (state.needReadable || + state.length < state.highWaterMark || + state.length === 0); +} + +// backwards compatibility. +Readable.prototype.setEncoding = function(enc) { + if (!StringDecoder) + StringDecoder = require('string_decoder/').StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; +}; + +// Don't raise the hwm > 128MB +var MAX_HWM = 0x800000; +function roundUpToNextPowerOf2(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 + n--; + for (var p = 1; p < 32; p <<= 1) n |= n >> p; + n++; + } + return n; +} + +function howMuchToRead(n, state) { + if (state.length === 0 && state.ended) + return 0; + + if (state.objectMode) + return n === 0 ? 0 : 1; + + if (isNaN(n) || util.isNull(n)) { + // only flow one buffer at a time + if (state.flowing && state.buffer.length) + return state.buffer[0].length; + else + return state.length; + } + + if (n <= 0) + return 0; + + // If we're asking for more than the target buffer level, + // then raise the water mark. Bump up to the next highest + // power of 2, to prevent increasing it excessively in tiny + // amounts. + if (n > state.highWaterMark) + state.highWaterMark = roundUpToNextPowerOf2(n); + + // don't have that much. return null, unless we've ended. + if (n > state.length) { + if (!state.ended) { + state.needReadable = true; + return 0; + } else + return state.length; + } + + return n; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function(n) { + debug('read', n); + var state = this._readableState; + var nOrig = n; + + if (!util.isNumber(n) || n > 0) + state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && + state.needReadable && + (state.length >= state.highWaterMark || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) + endReadable(this); + else + emitReadable(this); + return null; + } + + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) + endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } + + if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) + state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + } + + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (doRead && !state.reading) + n = howMuchToRead(nOrig, state); + + var ret; + if (n > 0) + ret = fromList(n, state); + else + ret = null; + + if (util.isNull(ret)) { + state.needReadable = true; + n = 0; + } + + state.length -= n; + + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (state.length === 0 && !state.ended) + state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended && state.length === 0) + endReadable(this); + + if (!util.isNull(ret)) + this.emit('data', ret); + + return ret; +}; + +function chunkInvalid(state, chunk) { + var er = null; + if (!util.isBuffer(chunk) && + !util.isString(chunk) && + !util.isNullOrUndefined(chunk) && + !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; +} + + +function onEofChunk(stream, state) { + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + + // emit 'readable' now to make sure it gets picked up. + emitReadable(stream); +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + if (state.sync) + process.nextTick(function() { + emitReadable_(stream); + }); + else + emitReadable_(stream); + } +} + +function emitReadable_(stream) { + debug('emit readable'); + stream.emit('readable'); + flow(stream); +} + + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + process.nextTick(function() { + maybeReadMore_(stream, state); + }); + } +} + +function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && + state.length < state.highWaterMark) { + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break; + else + len = state.length; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function(n) { + this.emit('error', new Error('not implemented')); +}; + +Readable.prototype.pipe = function(dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + + var doEnd = (!pipeOpts || pipeOpts.end !== false) && + dest !== process.stdout && + dest !== process.stderr; + + var endFn = doEnd ? onend : cleanup; + if (state.endEmitted) + process.nextTick(endFn); + else + src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable) { + debug('onunpipe'); + if (readable === src) { + cleanup(); + } + } + + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', cleanup); + src.removeListener('data', ondata); + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && + (!dest._writableState || dest._writableState.needDrain)) + ondrain(); + } + + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + var ret = dest.write(chunk); + if (false === ret) { + debug('false write response, pause', + src._readableState.awaitDrain); + src._readableState.awaitDrain++; + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EE.listenerCount(dest, 'error') === 0) + dest.emit('error', er); + } + // This is a brutally ugly hack to make sure that our error handler + // is attached before any userland ones. NEVER DO THIS. + if (!dest._events || !dest._events.error) + dest.on('error', onerror); + else if (isArray(dest._events.error)) + dest._events.error.unshift(onerror); + else + dest._events.error = [onerror, dest._events.error]; + + + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + + return dest; +}; + +function pipeOnDrain(src) { + return function() { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) + state.awaitDrain--; + if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; +} + + +Readable.prototype.unpipe = function(dest) { + var state = this._readableState; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) + return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) + return this; + + if (!dest) + dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) + dest.emit('unpipe', this); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + + for (var i = 0; i < len; i++) + dests[i].emit('unpipe', this); + return this; + } + + // try to find the right one. + var i = indexOf(state.pipes, dest); + if (i === -1) + return this; + + state.pipes.splice(i, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) + state.pipes = state.pipes[0]; + + dest.emit('unpipe', this); + + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function(ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + // If listening to data, and it has not explicitly been paused, + // then call resume to start the flow of data on the next tick. + if (ev === 'data' && false !== this._readableState.flowing) { + this.resume(); + } + + if (ev === 'readable' && this.readable) { + var state = this._readableState; + if (!state.readableListening) { + state.readableListening = true; + state.emittedReadable = false; + state.needReadable = true; + if (!state.reading) { + var self = this; + process.nextTick(function() { + debug('readable nexttick read 0'); + self.read(0); + }); + } else if (state.length) { + emitReadable(this, state); + } + } + } + + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function() { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + state.flowing = true; + if (!state.reading) { + debug('resume read 0'); + this.read(0); + } + resume(this, state); + } + return this; +}; + +function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + process.nextTick(function() { + resume_(stream, state); + }); + } +} + +function resume_(stream, state) { + state.resumeScheduled = false; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) + stream.read(0); +} + +Readable.prototype.pause = function() { + debug('call pause flowing=%j', this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + return this; +}; + +function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + if (state.flowing) { + do { + var chunk = stream.read(); + } while (null !== chunk && state.flowing); + } +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function(stream) { + var state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function() { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) + self.push(chunk); + } + + self.push(null); + }); + + stream.on('data', function(chunk) { + debug('wrapped data'); + if (state.decoder) + chunk = state.decoder.write(chunk); + if (!chunk || !state.objectMode && !chunk.length) + return; + + var ret = self.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (util.isFunction(stream[i]) && util.isUndefined(this[i])) { + this[i] = function(method) { return function() { + return stream[method].apply(stream, arguments); + }}(i); + } + } + + // proxy certain important events. + var events = ['error', 'close', 'destroy', 'pause', 'resume']; + forEach(events, function(ev) { + stream.on(ev, self.emit.bind(self, ev)); + }); + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function(n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + + return self; +}; + + + +// exposed for testing purposes only. +Readable._fromList = fromList; + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +function fromList(n, state) { + var list = state.buffer; + var length = state.length; + var stringMode = !!state.decoder; + var objectMode = !!state.objectMode; + var ret; + + // nothing in the list, definitely empty. + if (list.length === 0) + return null; + + if (length === 0) + ret = null; + else if (objectMode) + ret = list.shift(); + else if (!n || n >= length) { + // read it all, truncate the array. + if (stringMode) + ret = list.join(''); + else + ret = Buffer.concat(list, length); + list.length = 0; + } else { + // read just some of it. + if (n < list[0].length) { + // just take a part of the first list item. + // slice is the same for buffers and strings. + var buf = list[0]; + ret = buf.slice(0, n); + list[0] = buf.slice(n); + } else if (n === list[0].length) { + // first list is a perfect match + ret = list.shift(); + } else { + // complex case. + // we have enough to cover it, but it spans past the first buffer. + if (stringMode) + ret = ''; + else + ret = new Buffer(n); + + var c = 0; + for (var i = 0, l = list.length; i < l && c < n; i++) { + var buf = list[0]; + var cpy = Math.min(n - c, buf.length); + + if (stringMode) + ret += buf.slice(0, cpy); + else + buf.copy(ret, c, 0, cpy); + + if (cpy < buf.length) + list[0] = buf.slice(cpy); + else + list.shift(); + + c += cpy; + } + } + } + + return ret; +} + +function endReadable(stream) { + var state = stream._readableState; + + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) + throw new Error('endReadable called on non-empty stream'); + + if (!state.endEmitted) { + state.ended = true; + process.nextTick(function() { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } + }); + } +} + +function forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +function indexOf (xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} + +}).call(this,require('_process')) +},{"./_stream_duplex":86,"_process":84,"buffer":76,"core-util-is":91,"events":80,"inherits":81,"isarray":82,"stream":96,"string_decoder/":97,"util":75}],89:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + +module.exports = Transform; + +var Duplex = require('./_stream_duplex'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(Transform, Duplex); + + +function TransformState(options, stream) { + this.afterTransform = function(er, data) { + return afterTransform(stream, er, data); + }; + + this.needTransform = false; + this.transforming = false; + this.writecb = null; + this.writechunk = null; +} + +function afterTransform(stream, er, data) { + var ts = stream._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) + return stream.emit('error', new Error('no writecb in Transform class')); + + ts.writechunk = null; + ts.writecb = null; + + if (!util.isNullOrUndefined(data)) + stream.push(data); + + if (cb) + cb(er); + + var rs = stream._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + stream._read(rs.highWaterMark); + } +} + + +function Transform(options) { + if (!(this instanceof Transform)) + return new Transform(options); + + Duplex.call(this, options); + + this._transformState = new TransformState(options, this); + + // when the writable side finishes, then flush out anything remaining. + var stream = this; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + + this.once('prefinish', function() { + if (util.isFunction(this._flush)) + this._flush(function(er) { + done(stream, er); + }); + else + done(stream); + }); +} + +Transform.prototype.push = function(chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function(chunk, encoding, cb) { + throw new Error('not implemented'); +}; + +Transform.prototype._write = function(chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || + rs.needReadable || + rs.length < rs.highWaterMark) + this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function(n) { + var ts = this._transformState; + + if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; + + +function done(stream, er) { + if (er) + return stream.emit('error', er); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + var ws = stream._writableState; + var ts = stream._transformState; + + if (ws.length) + throw new Error('calling transform done when ws.length != 0'); + + if (ts.transforming) + throw new Error('calling transform done when still transforming'); + + return stream.push(null); +} + +},{"./_stream_duplex":86,"core-util-is":91,"inherits":81}],90:[function(require,module,exports){ +(function (process){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, cb), and it'll handle all +// the drain event emission and buffering. + +module.exports = Writable; + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Writable.WritableState = WritableState; + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Stream = require('stream'); + +util.inherits(Writable, Stream); + +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; +} + +function WritableState(options, stream) { + var Duplex = require('./_stream_duplex'); + + options = options || {}; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + var defaultHwm = options.objectMode ? 16 : 16 * 1024; + this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) + this.objectMode = this.objectMode || !!options.writableObjectMode; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function(er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + + this.buffer = []; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; +} + +function Writable(options) { + var Duplex = require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, though they're not + // instanceof Writable, they're instanceof Readable. + if (!(this instanceof Writable) && !(this instanceof Duplex)) + return new Writable(options); + + this._writableState = new WritableState(options, this); + + // legacy. + this.writable = true; + + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function() { + this.emit('error', new Error('Cannot pipe. Not readable.')); +}; + + +function writeAfterEnd(stream, state, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + process.nextTick(function() { + cb(er); + }); +} + +// If we get something that is not a buffer, string, null, or undefined, +// and we're not in objectMode, then that's an error. +// Otherwise stream chunks are all considered to be of length=1, and the +// watermarks determine how many objects to keep in the buffer, rather than +// how many bytes or characters. +function validChunk(stream, state, chunk, cb) { + var valid = true; + if (!util.isBuffer(chunk) && + !util.isString(chunk) && + !util.isNullOrUndefined(chunk) && + !state.objectMode) { + var er = new TypeError('Invalid non-string/buffer chunk'); + stream.emit('error', er); + process.nextTick(function() { + cb(er); + }); + valid = false; + } + return valid; +} + +Writable.prototype.write = function(chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + + if (util.isFunction(encoding)) { + cb = encoding; + encoding = null; + } + + if (util.isBuffer(chunk)) + encoding = 'buffer'; + else if (!encoding) + encoding = state.defaultEncoding; + + if (!util.isFunction(cb)) + cb = function() {}; + + if (state.ended) + writeAfterEnd(this, state, cb); + else if (validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, chunk, encoding, cb); + } + + return ret; +}; + +Writable.prototype.cork = function() { + var state = this._writableState; + + state.corked++; +}; + +Writable.prototype.uncork = function() { + var state = this._writableState; + + if (state.corked) { + state.corked--; + + if (!state.writing && + !state.corked && + !state.finished && + !state.bufferProcessing && + state.buffer.length) + clearBuffer(this, state); + } +}; + +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && + state.decodeStrings !== false && + util.isString(chunk)) { + chunk = new Buffer(chunk, encoding); + } + return chunk; +} + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, chunk, encoding, cb) { + chunk = decodeChunk(state, chunk, encoding); + if (util.isBuffer(chunk)) + encoding = 'buffer'; + var len = state.objectMode ? 1 : chunk.length; + + state.length += len; + + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) + state.needDrain = true; + + if (state.writing || state.corked) + state.buffer.push(new WriteReq(chunk, encoding, cb)); + else + doWrite(stream, state, false, len, chunk, encoding, cb); + + return ret; +} + +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (writev) + stream._writev(chunk, state.onwrite); + else + stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} + +function onwriteError(stream, state, sync, er, cb) { + if (sync) + process.nextTick(function() { + state.pendingcb--; + cb(er); + }); + else { + state.pendingcb--; + cb(er); + } + + stream._writableState.errorEmitted = true; + stream.emit('error', er); +} + +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} + +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) + onwriteError(stream, state, sync, er, cb); + else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(stream, state); + + if (!finished && + !state.corked && + !state.bufferProcessing && + state.buffer.length) { + clearBuffer(stream, state); + } + + if (sync) { + process.nextTick(function() { + afterWrite(stream, state, finished, cb); + }); + } else { + afterWrite(stream, state, finished, cb); + } + } +} + +function afterWrite(stream, state, finished, cb) { + if (!finished) + onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + + if (stream._writev && state.buffer.length > 1) { + // Fast case, write everything using _writev() + var cbs = []; + for (var c = 0; c < state.buffer.length; c++) + cbs.push(state.buffer[c].callback); + + // count the one we are adding, as well. + // TODO(isaacs) clean this up + state.pendingcb++; + doWrite(stream, state, true, state.length, state.buffer, '', function(err) { + for (var i = 0; i < cbs.length; i++) { + state.pendingcb--; + cbs[i](err); + } + }); + + // Clear buffer + state.buffer = []; + } else { + // Slow case, write chunks one-by-one + for (var c = 0; c < state.buffer.length; c++) { + var entry = state.buffer[c]; + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, false, len, chunk, encoding, cb); + + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + c++; + break; + } + } + + if (c < state.buffer.length) + state.buffer = state.buffer.slice(c); + else + state.buffer.length = 0; + } + + state.bufferProcessing = false; +} + +Writable.prototype._write = function(chunk, encoding, cb) { + cb(new Error('not implemented')); + +}; + +Writable.prototype._writev = null; + +Writable.prototype.end = function(chunk, encoding, cb) { + var state = this._writableState; + + if (util.isFunction(chunk)) { + cb = chunk; + chunk = null; + encoding = null; + } else if (util.isFunction(encoding)) { + cb = encoding; + encoding = null; + } + + if (!util.isNullOrUndefined(chunk)) + this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) + endWritable(this, state, cb); +}; + + +function needFinish(stream, state) { + return (state.ending && + state.length === 0 && + !state.finished && + !state.writing); +} + +function prefinish(stream, state) { + if (!state.prefinished) { + state.prefinished = true; + stream.emit('prefinish'); + } +} + +function finishMaybe(stream, state) { + var need = needFinish(stream, state); + if (need) { + if (state.pendingcb === 0) { + prefinish(stream, state); + state.finished = true; + stream.emit('finish'); + } else + prefinish(stream, state); + } + return need; +} + +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) + process.nextTick(cb); + else + stream.once('finish', cb); + } + state.ended = true; +} + +}).call(this,require('_process')) +},{"./_stream_duplex":86,"_process":84,"buffer":76,"core-util-is":91,"inherits":81,"stream":96}],91:[function(require,module,exports){ +(function (Buffer){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. +function isArray(ar) { + return Array.isArray(ar); +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return isObject(re) && objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; + +function isError(e) { + return isObject(e) && + (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +function isBuffer(arg) { + return Buffer.isBuffer(arg); +} +exports.isBuffer = isBuffer; + +function objectToString(o) { + return Object.prototype.toString.call(o); +} +}).call(this,require("buffer").Buffer) +},{"buffer":76}],92:[function(require,module,exports){ +module.exports = require("./lib/_stream_passthrough.js") + +},{"./lib/_stream_passthrough.js":87}],93:[function(require,module,exports){ +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = require('stream'); +exports.Readable = exports; +exports.Writable = require('./lib/_stream_writable.js'); +exports.Duplex = require('./lib/_stream_duplex.js'); +exports.Transform = require('./lib/_stream_transform.js'); +exports.PassThrough = require('./lib/_stream_passthrough.js'); + +},{"./lib/_stream_duplex.js":86,"./lib/_stream_passthrough.js":87,"./lib/_stream_readable.js":88,"./lib/_stream_transform.js":89,"./lib/_stream_writable.js":90,"stream":96}],94:[function(require,module,exports){ +module.exports = require("./lib/_stream_transform.js") + +},{"./lib/_stream_transform.js":89}],95:[function(require,module,exports){ +module.exports = require("./lib/_stream_writable.js") + +},{"./lib/_stream_writable.js":90}],96:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Stream; + +var EE = require('events').EventEmitter; +var inherits = require('inherits'); + +inherits(Stream, EE); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + +},{"events":80,"inherits":81,"readable-stream/duplex.js":85,"readable-stream/passthrough.js":92,"readable-stream/readable.js":93,"readable-stream/transform.js":94,"readable-stream/writable.js":95}],97:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var Buffer = require('buffer').Buffer; + +var isBufferEncoding = Buffer.isEncoding + || function(encoding) { + switch (encoding && encoding.toLowerCase()) { + case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; + default: return false; + } + } + + +function assertEncoding(encoding) { + if (encoding && !isBufferEncoding(encoding)) { + throw new Error('Unknown encoding: ' + encoding); + } +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. CESU-8 is handled as part of the UTF-8 encoding. +// +// @TODO Handling all encodings inside a single object makes it very difficult +// to reason about this code, so it should be split up in the future. +// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code +// points as used by CESU-8. +var StringDecoder = exports.StringDecoder = function(encoding) { + this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); + assertEncoding(encoding); + switch (this.encoding) { + case 'utf8': + // CESU-8 represents each of Surrogate Pair by 3-bytes + this.surrogateSize = 3; + break; + case 'ucs2': + case 'utf16le': + // UTF-16 represents each of Surrogate Pair by 2-bytes + this.surrogateSize = 2; + this.detectIncompleteChar = utf16DetectIncompleteChar; + break; + case 'base64': + // Base-64 stores 3 bytes in 4 chars, and pads the remainder. + this.surrogateSize = 3; + this.detectIncompleteChar = base64DetectIncompleteChar; + break; + default: + this.write = passThroughWrite; + return; + } + + // Enough space to store all bytes of a single character. UTF-8 needs 4 + // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). + this.charBuffer = new Buffer(6); + // Number of bytes received for the current incomplete multi-byte character. + this.charReceived = 0; + // Number of bytes expected for the current incomplete multi-byte character. + this.charLength = 0; +}; + + +// write decodes the given buffer and returns it as JS string that is +// guaranteed to not contain any partial multi-byte characters. Any partial +// character found at the end of the buffer is buffered up, and will be +// returned when calling write again with the remaining bytes. +// +// Note: Converting a Buffer containing an orphan surrogate to a String +// currently works, but converting a String to a Buffer (via `new Buffer`, or +// Buffer#write) will replace incomplete surrogates with the unicode +// replacement character. See https://codereview.chromium.org/121173009/ . +StringDecoder.prototype.write = function(buffer) { + var charStr = ''; + // if our last write ended with an incomplete multibyte character + while (this.charLength) { + // determine how many remaining bytes this buffer has to offer for this char + var available = (buffer.length >= this.charLength - this.charReceived) ? + this.charLength - this.charReceived : + buffer.length; + + // add the new bytes to the char buffer + buffer.copy(this.charBuffer, this.charReceived, 0, available); + this.charReceived += available; + + if (this.charReceived < this.charLength) { + // still not enough chars in this buffer? wait for more ... + return ''; + } + + // remove bytes belonging to the current character from the buffer + buffer = buffer.slice(available, buffer.length); + + // get the character that was split + charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); + + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + var charCode = charStr.charCodeAt(charStr.length - 1); + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + this.charLength += this.surrogateSize; + charStr = ''; + continue; + } + this.charReceived = this.charLength = 0; + + // if there are no more bytes in this buffer, just emit our char + if (buffer.length === 0) { + return charStr; + } + break; + } + + // determine and set charLength / charReceived + this.detectIncompleteChar(buffer); + + var end = buffer.length; + if (this.charLength) { + // buffer the incomplete character bytes we got + buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); + end -= this.charReceived; + } + + charStr += buffer.toString(this.encoding, 0, end); + + var end = charStr.length - 1; + var charCode = charStr.charCodeAt(end); + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + var size = this.surrogateSize; + this.charLength += size; + this.charReceived += size; + this.charBuffer.copy(this.charBuffer, size, 0, size); + buffer.copy(this.charBuffer, 0, 0, size); + return charStr.substring(0, end); + } + + // or just emit the charStr + return charStr; +}; + +// detectIncompleteChar determines if there is an incomplete UTF-8 character at +// the end of the given buffer. If so, it sets this.charLength to the byte +// length that character, and sets this.charReceived to the number of bytes +// that are available for this character. +StringDecoder.prototype.detectIncompleteChar = function(buffer) { + // determine how many bytes we have to check at the end of this buffer + var i = (buffer.length >= 3) ? 3 : buffer.length; + + // Figure out if one of the last i bytes of our buffer announces an + // incomplete char. + for (; i > 0; i--) { + var c = buffer[buffer.length - i]; + + // See http://en.wikipedia.org/wiki/UTF-8#Description + + // 110XXXXX + if (i == 1 && c >> 5 == 0x06) { + this.charLength = 2; + break; + } + + // 1110XXXX + if (i <= 2 && c >> 4 == 0x0E) { + this.charLength = 3; + break; + } + + // 11110XXX + if (i <= 3 && c >> 3 == 0x1E) { + this.charLength = 4; + break; + } + } + this.charReceived = i; +}; + +StringDecoder.prototype.end = function(buffer) { + var res = ''; + if (buffer && buffer.length) + res = this.write(buffer); + + if (this.charReceived) { + var cr = this.charReceived; + var buf = this.charBuffer; + var enc = this.encoding; + res += buf.slice(0, cr).toString(enc); + } + + return res; +}; + +function passThroughWrite(buffer) { + return buffer.toString(this.encoding); +} + +function utf16DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 2; + this.charLength = this.charReceived ? 2 : 0; +} + +function base64DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 3; + this.charLength = this.charReceived ? 3 : 0; +} + +},{"buffer":76}]},{},[3]); diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js new file mode 100644 index 0000000..e846c5c --- /dev/null +++ b/examples/file-uploader/js/upload.js @@ -0,0 +1,176 @@ +const Type = require('union-type'); + +const map = require('ramda/src/map') + , reduce = require('ramda/src/reduce') + , curry = require('ramda/src/curry') + , find = require('ramda/src/find') + , always = require('ramda/src/always') + , merge = require('ramda/src/merge') + , evolve = require('ramda/src/evolve') +; + +const h = require('snabbdom/h') + , s = require('./svg'); + +const noop = function(){}; + +// model + +const init = (files) => { + return { + status: 'initial', + progress: {}, + abort: noop, + title: (files.length === 1 + ? files[0].name + : '(' + files.length + ' files)' ), + files: map(initFile, files) + } +} + +const initFile = ({name,lastModifiedDate,size,type}) => { + return {name,lastModifiedDate,size,type} +} + +const statusLabel = (model) => { + return { + 'initial': null, + 'uploading': 'uploading', + 'processing': 'processing', + 'uploaded': 'done', + 'error': 'error', + 'abort': 'stopped' + }[model.status] || null ; +} + +const actionLabel = (action) => { + return { + 'abort': 'stop' + }[action] || null ; +} + +const size = (model) => { + return reduce( (tot,file) => tot + (file.size || 0), 0, model.files ); +} + +const status = curry( (s, model) => model.status == s ); +const uploading = status('uploading'); + +const aborted = (model) => { + return model.status == 'aborted'; +} + +const abortable = (model) => { + return !!model.abort && !!find(model.status, ['uploading']); +} + +const hasProgressData = (x) => { + return !(x.loaded === undefined || x.total === undefined); +} + +const percentProgress = (p) => { + if (!hasProgressData(p)) return null; + return p.loaded / p.total; +} + + +// action + +// NOTE: no async tasks initiated, so all updates simply return changed state + +const Action = Type({ + Progress: [hasProgressData, Function], + Uploaded: [], + Error: [], + Abort: [] +}); + +const update = Action.caseOn({ + Progress: ({loaded,total},abort,model) => { + return evolve({ status: always(loaded < total ? 'uploading' : 'processing'), + progress: always({loaded, total}), + abort: always(abort) + })(model); + }, + Uploaded: evolve({status: always('uploaded')}), + Error: evolve({status: always('error')}), + Abort: evolve({status: always('abort')}) +}); + + +// view + +const view = curry( ({progress},model) => { + progress = merge({width: 200, height: 20}, progress || {}); + + return ( + h('div.upload', {}, [ + h('div.title', {} [ renderTitle(model) ]), + h('div.progress', {}, [ renderProgress(model,progress) ]), + h('div.status', {}, [ renderStatus(model) ]), + h('div.abort', {}, [ renderAbort(model) ]) + ]) + ); + +}); + +function renderTitle(model){ + const titlespan = h('span.title', {}, model.title); + const sizespan = h('span.size', {}, '' + size(model)); // TODO readable bytesize + return ( + model.url + ? h('a', { attr: {'href': model.url, + 'target': '_blank' + } + }, [ titlespan, sizespan ]) + + : h('span', {}, [ titlespan, sizespan]) + ); +} + +function renderProgress(model,specs){ + const barwidth = percentProgress(model.progress) * specs.width; + const linespecs = { x1: specs.width, x2: specs.width, + y1: 0, y2: specs.height }; + + const rect = ( + s('rect.bar', { attr: { height: specs.height, + width: barwidth + } + } ) + ); + + const line = ( + s('line.end', { attr: linespecs } ) + ); + + return ( + s('svg', {attr: specs}, [ + s('g', {}, (barwidth > 0) && uploading(model) ? [rect,line] : []) + ]) + ); + +} + +function renderStatus(model){ + const label = statusLabel(model); + return h('span', {}, label); +} + + +function renderAbort(model){ + const label = actionLabel('abort'); + return h('a', { style: visible(abortable, model), + on: { click: model.abort } }, + label + ); +} + +function visible(pred,model){ + return { display: pred(model) ? null : 'none' } +} + + +module.exports = {init, Action, update, view}; + + diff --git a/examples/file-uploader/js/uploader.js b/examples/file-uploader/js/uploader.js new file mode 100644 index 0000000..4bd588a --- /dev/null +++ b/examples/file-uploader/js/uploader.js @@ -0,0 +1,61 @@ +/* globals XMLHttpRequest, FormData */ + +const compose = require('ramda/src/compose') + , __ = require('ramda/src/__') + , curry = require('ramda/src/curry') +; +const Type = require('union-type'); +const Future = require('ramda-fantasy/src/Future'); + +const identity = (x) => x ; + +const Result = Type({ + OK: [Object], + NotFound: [Object], + Error: [Object], + Abort: [Object], + Unknown: [Object], + Progress: [Object, Function] +}); + + +const upload = curry( (headers, url, files) => { + headers = headers || {}; + progress = progress || identity; + + return new Future( (rej,res) => { + const xhr = new XMLHttpRequest(); + const getxhr = always(xhr); + const abort = xhr.abort.bind(xhr); + xhr.addEventListener("load", compose(res, deriveResult, getxhr), false); + xhr.addEventListener("abort", compose(res, Result.Abort, getxhr), false); + xhr.addEventListener("error", compose(res, Result.Error, getxhr), false); + + xhr.upload.addEventListener("progress", + compose(res, Result.Progress(__,abort)), false); + + xhr.open("post", url, true); + for (k in headers){ + xhr.setRequestHeader(k, headers[k]); + } + xhr.send(formdata(files)); + }); +}); + +module.exports = {upload, Result} + + +function deriveResult(xhr){ + return (xhr.status < 400 ? Result.OK : + xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : + xhr.status >= 500 ? Result.Error : + Result.Unknown + ); +} + +function formdata(files){ + const data = new FormData(); + for (let i=0; i Date: Thu, 27 Aug 2015 23:15:09 -0400 Subject: [PATCH 2/9] file-uploader example: finish implementation - add test server - add index.html - debug app, uploader, main - change file input to accept multiple --- examples/file-uploader/.gitignore | 1 + examples/file-uploader/index.html | 13 + examples/file-uploader/js/app.js | 16 +- examples/file-uploader/js/build.js | 10482 ++++++++++++++++++++++++ examples/file-uploader/js/list.js | 18 +- examples/file-uploader/js/main.js | 3 +- examples/file-uploader/js/upload.js | 39 +- examples/file-uploader/js/uploader.js | 12 +- examples/file-uploader/package.json | 7 +- examples/file-uploader/server.js | 100 + 10 files changed, 10647 insertions(+), 44 deletions(-) create mode 100644 examples/file-uploader/.gitignore create mode 100644 examples/file-uploader/index.html create mode 100644 examples/file-uploader/js/build.js create mode 100644 examples/file-uploader/server.js diff --git a/examples/file-uploader/.gitignore b/examples/file-uploader/.gitignore new file mode 100644 index 0000000..dc6e631 --- /dev/null +++ b/examples/file-uploader/.gitignore @@ -0,0 +1 @@ +uploads/* diff --git a/examples/file-uploader/index.html b/examples/file-uploader/index.html new file mode 100644 index 0000000..92a6b43 --- /dev/null +++ b/examples/file-uploader/index.html @@ -0,0 +1,13 @@ + + + + + File Uploader + + + + +
+ + diff --git a/examples/file-uploader/js/app.js b/examples/file-uploader/js/app.js index c43727f..400a69f 100644 --- a/examples/file-uploader/js/app.js +++ b/examples/file-uploader/js/app.js @@ -1,7 +1,9 @@ + const Type = require('union-type'); const T = require('ramda/src/T') - , evolve = require('ramda/src/evolve') + , assoc = require('ramda/src/assoc') , curry = require('ramda/src/curry') + , compose = require('ramda/src/compose') , map = require('ramda/src/map') , invoker = require('ramda/src/invoker') ; @@ -9,19 +11,19 @@ const h = require('snabbdom/h'); const uploadList = require('./list'); const uploader = require('./uploader'); - + // action const listUpdate = (listAction,model) => { - const [state, tasks] = uploadList.update(listAction); - return [ evolve({uploads: state},model), + const [state, tasks] = uploadList.update(listAction, model.uploads); + return [ assoc('uploads', state, model), tasks.map( map(Action.Route) ) ]; } const Action = Type({ - Create: [Function,Array], + Create: [T, T], Route: [uploadList.Action] }); @@ -36,7 +38,7 @@ const update = Action.caseOn({ // model -const init = () = { uploads: uploadList.init() } +const init = () => { return { uploads: uploadList.init() }; } // view @@ -47,7 +49,7 @@ const view = curry( ({url, headers, action$}, model) => { const form = ( h('form', {on: {submit: preventDefault} }, [ h('input', - { attr: {'type': 'file'}, + { props: {type: 'file', multiple: true}, on: { change: compose(action$, Action.Create(up), getTarget('files')) } diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js new file mode 100644 index 0000000..69d29ba --- /dev/null +++ b/examples/file-uploader/js/build.js @@ -0,0 +1,10482 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 0 ? [rect, line] : [])]); +} + +function renderStatus(model) { + var label = statusLabel(model); + return h('span', {}, label); +} + +function renderAbort(model) { + var label = actionLabel('abort'); + return h('a', { style: visible(abortable, model), + on: { click: model.abort } }, label); +} + +function visible(pred, model) { + return { display: pred(model) ? null : 'none' }; +} + +module.exports = { init: init, Action: Action, update: update, view: view }; + +},{"./svg":4,"ramda/src/always":12,"ramda/src/contains":17,"ramda/src/curry":18,"ramda/src/evolve":21,"ramda/src/map":57,"ramda/src/merge":58,"ramda/src/reduce":60,"snabbdom/h":68,"union-type":82}],6:[function(require,module,exports){ +/* globals XMLHttpRequest, FormData */ + +'use strict'; + +var compose = require('ramda/src/compose'), + __ = require('ramda/src/__'), + curry = require('ramda/src/curry'), + always = require('ramda/src/always'); +var Type = require('union-type'); +var Future = require('ramda-fantasy/src/Future'); + +var identity = function identity(x) { + return x; +}; + +var Result = Type({ + OK: [Object], + NotFound: [Object], + Error: [Object], + Abort: [Object], + Unknown: [Object], + Progress: [Function, Object] +}); + +var upload = curry(function (headers, url, files) { + headers = headers || {}; + + return new Future(function (rej, res) { + var xhr = new XMLHttpRequest(); + var getxhr = always(xhr); + var abort = xhr.abort.bind(xhr); + xhr.addEventListener('load', compose(res, deriveResult, getxhr), false); + xhr.addEventListener('abort', compose(res, Result.Abort(xhr)), false); + xhr.addEventListener('error', compose(res, Result.Error(xhr)), false); + + xhr.upload.addEventListener('progress', compose(res, Result.Progress(abort)), false); + + xhr.open('post', url, true); + for (k in headers) { + xhr.setRequestHeader(k, headers[k]); + } + xhr.send(formdata(files)); + }); +}); + +module.exports = { upload: upload, Result: Result }; + +function deriveResult(xhr) { + return (xhr.status < 400 ? Result.OK : xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : xhr.status >= 500 ? Result.Error : Result.Unknown)(xhr); +} + +function formdata(files) { + var data = new FormData(); + for (var i = 0; i < files.length; ++i) { + data.append(files[i].name, files[i]); + }return data; +} + +},{"ramda-fantasy/src/Future":7,"ramda/src/__":10,"ramda/src/always":12,"ramda/src/compose":16,"ramda/src/curry":18,"union-type":82}],7:[function(require,module,exports){ +var R = require('ramda'); + +// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success) +function Future(f) { + if (!(this instanceof Future)) { + return new Future(f); + } + this._fork = f; +} + +Future.prototype.fork = function(reject, resolve) { + try { + this._fork(reject, resolve); + } catch(e) { + reject(e); + } +}; + +// functor +Future.prototype.map = function(f) { + return this.chain(function(a) { return Future.of(f(a)); }); +}; + +// apply +Future.prototype.ap = function(m) { + var self = this; + + return new Future(function(rej, res) { + var applyFn, val; + var doReject = R.once(rej); + + function resolveIfDone() { + if (applyFn != null && val != null) { + return res(applyFn(val)); + } + } + + self.fork(doReject, function(fn) { + applyFn = fn; + resolveIfDone(); + }); + + m.fork(doReject, function(v) { + val = v; + resolveIfDone(); + }); + + }); + +}; + +// applicative +Future.of = function(x) { + // should include a default rejection? + return new Future(function(_, resolve) { return resolve(x); }); +}; + +Future.prototype.of = Future.of; + +// chain +// f must be a function which returns a value +// f must return a value of the same Chain +// chain must return a value of the same Chain +//:: Future a, b => (b -> Future c) -> Future c +Future.prototype.chain = function(f) { // Sorella's: + return new Future(function(reject, resolve) { + return this.fork(function(a) { return reject(a); }, + function(b) { return f(b).fork(reject, resolve); }); + }.bind(this)); +}; + +// chainReject +// Like chain but operates on the reject instead of the resolve case. +//:: Future a, b => (a -> Future c) -> Future c +Future.prototype.chainReject = function(f) { + return new Future(function(reject, resolve) { + return this.fork(function(a) { return f(a).fork(reject, resolve); }, + function(b) { return resolve(b); + }); + }.bind(this)); +}; + +// monad +// A value that implements the Monad specification must also implement the Applicative and Chain specifications. +// see above. + +Future.prototype.bimap = function(errFn, successFn) { + var self = this; + return new Future(function(reject, resolve) { + self.fork(function(err) { + reject(errFn(err)); + }, function(val) { + resolve(successFn(val)); + }); + }); +}; + +Future.reject = function(val) { + return new Future(function(reject) { + reject(val); + }); +}; + +Future.prototype.toString = function() { + return 'Future(' + R.toString(this._fork) + ')'; +}; + +Future.memoize = function(f) { + var status = 'IDLE'; + var listeners = []; + var cachedValue; + + var handleCompletion = R.curry(function(newStatus, cb, val) { + status = newStatus; + cachedValue = val; + cb(val); + R.forEach(function(listener) { + listener[status](cachedValue); + }, listeners); + }); + + function addListeners(reject, resolve) { + listeners.push({ REJECTED: reject, RESOLVED: resolve } ); + } + + function doResolve(reject, resolve) { + status = 'PENDING'; + return f.fork( + handleCompletion('REJECTED', reject), + handleCompletion('RESOLVED', resolve) + ); + } + + return new Future(function(reject, resolve) { + + switch(status) { + case 'IDLE': doResolve(reject, resolve); break; + case 'PENDING': addListeners(reject, resolve); break; + case 'REJECTED': reject(cachedValue); break; + case 'RESOLVED': resolve(cachedValue); break; + } + + }); +}; + +module.exports = Future; + +},{"ramda":8}],8:[function(require,module,exports){ +// Ramda v0.17.1 +// https://github.com/ramda/ramda +// (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers +// Ramda may be freely distributed under the MIT license. + +;(function() { + + 'use strict'; + + /** + * A special placeholder value used to specify "gaps" within curried functions, + * allowing partial application of any combination of arguments, + * regardless of their positions. + * + * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2, _)(1, 3)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @constant + * @memberOf R + * @category Function + * @example + * + * var greet = R.replace('{name}', R.__, 'Hello, {name}!'); + * greet('Alice'); //=> 'Hello, Alice!' + */ + var __ = { '@@functional/placeholder': true }; + + // jshint unused:vars + var _arity = function _arity(n, fn) { + // jshint unused:vars + switch (n) { + case 0: + return function () { + return fn.apply(this, arguments); + }; + case 1: + return function (a0) { + return fn.apply(this, arguments); + }; + case 2: + return function (a0, a1) { + return fn.apply(this, arguments); + }; + case 3: + return function (a0, a1, a2) { + return fn.apply(this, arguments); + }; + case 4: + return function (a0, a1, a2, a3) { + return fn.apply(this, arguments); + }; + case 5: + return function (a0, a1, a2, a3, a4) { + return fn.apply(this, arguments); + }; + case 6: + return function (a0, a1, a2, a3, a4, a5) { + return fn.apply(this, arguments); + }; + case 7: + return function (a0, a1, a2, a3, a4, a5, a6) { + return fn.apply(this, arguments); + }; + case 8: + return function (a0, a1, a2, a3, a4, a5, a6, a7) { + return fn.apply(this, arguments); + }; + case 9: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) { + return fn.apply(this, arguments); + }; + case 10: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return fn.apply(this, arguments); + }; + default: + throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); + } + }; + + var _cloneRegExp = function _cloneRegExp(pattern) { + return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : '')); + }; + + var _complement = function _complement(f) { + return function () { + return !f.apply(this, arguments); + }; + }; + + /** + * Private `concat` function to merge two array-like objects. + * + * @private + * @param {Array|Arguments} [set1=[]] An array-like object. + * @param {Array|Arguments} [set2=[]] An array-like object. + * @return {Array} A new, merged array. + * @example + * + * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + */ + var _concat = function _concat(set1, set2) { + set1 = set1 || []; + set2 = set2 || []; + var idx; + var len1 = set1.length; + var len2 = set2.length; + var result = []; + idx = 0; + while (idx < len1) { + result[result.length] = set1[idx]; + idx += 1; + } + idx = 0; + while (idx < len2) { + result[result.length] = set2[idx]; + idx += 1; + } + return result; + }; + + var _containsWith = function _containsWith(pred, x, list) { + var idx = 0, len = list.length; + while (idx < len) { + if (pred(x, list[idx])) { + return true; + } + idx += 1; + } + return false; + }; + + /** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry1 = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn.apply(this, arguments); + } + }; + }; + + /** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry2 = function _curry2(fn) { + return function f2(a, b) { + var n = arguments.length; + if (n === 0) { + return f2; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f2; + } else if (n === 1) { + return _curry1(function (b) { + return fn(a, b); + }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return f2; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function (a) { + return fn(a, b); + }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function (b) { + return fn(a, b); + }); + } else { + return fn(a, b); + } + }; + }; + + /** + * Optimized internal three-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ + var _curry3 = function _curry3(fn) { + return function f3(a, b, c) { + var n = arguments.length; + if (n === 0) { + return f3; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f3; + } else if (n === 1) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return f3; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry2(function (a, c) { + return fn(a, b, c); + }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 2) { + return _curry1(function (c) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return f3; + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function (a, b) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return _curry2(function (a, c) { + return fn(a, b, c); + }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) { + return _curry2(function (b, c) { + return fn(a, b, c); + }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function (a) { + return fn(a, b, c); + }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function (b) { + return fn(a, b, c); + }); + } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) { + return _curry1(function (c) { + return fn(a, b, c); + }); + } else { + return fn(a, b, c); + } + }; + }; + + /** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ + var _curryN = function _curryN(length, received, fn) { + return function () { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn)); + }; + }; + + var _filter = function _filter(fn, list) { + var idx = 0, len = list.length, result = []; + while (idx < len) { + if (fn(list[idx])) { + result[result.length] = list[idx]; + } + idx += 1; + } + return result; + }; + + var _forceReduced = function _forceReduced(x) { + return { + '@@transducer/value': x, + '@@transducer/reduced': true + }; + }; + + /** + * @private + * @param {Function} fn The strategy for extracting function names from an object + * @return {Function} A function that takes an object and returns an array of function names. + */ + var _functionsWith = function _functionsWith(fn) { + return function (obj) { + return _filter(function (key) { + return typeof obj[key] === 'function'; + }, fn(obj)); + }; + }; + + var _has = function _has(prop, obj) { + return Object.prototype.hasOwnProperty.call(obj, prop); + }; + + var _identity = function _identity(x) { + return x; + }; + + /** + * Tests whether or not an object is an array. + * + * @private + * @param {*} val The object to test. + * @return {Boolean} `true` if `val` is an array, `false` otherwise. + * @example + * + * _isArray([]); //=> true + * _isArray(null); //=> false + * _isArray({}); //=> false + */ + var _isArray = Array.isArray || function _isArray(val) { + return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]'; + }; + + /** + * Determine if the passed argument is an integer. + * + * @private + * @param {*} n + * @category Type + * @return {Boolean} + */ + var _isInteger = Number.isInteger || function _isInteger(n) { + return n << 0 === n; + }; + + var _isNumber = function _isNumber(x) { + return Object.prototype.toString.call(x) === '[object Number]'; + }; + + var _isString = function _isString(x) { + return Object.prototype.toString.call(x) === '[object String]'; + }; + + var _isTransformer = function _isTransformer(obj) { + return typeof obj['@@transducer/step'] === 'function'; + }; + + var _map = function _map(fn, list) { + var idx = 0, len = list.length, result = Array(len); + while (idx < len) { + result[idx] = fn(list[idx]); + idx += 1; + } + return result; + }; + + var _pipe = function _pipe(f, g) { + return function () { + return g.call(this, f.apply(this, arguments)); + }; + }; + + var _pipeP = function _pipeP(f, g) { + return function () { + var ctx = this; + return f.apply(ctx, arguments).then(function (x) { + return g.call(ctx, x); + }); + }; + }; + + var _quote = function _quote(s) { + return '"' + s.replace(/"/g, '\\"') + '"'; + }; + + var _reduced = function _reduced(x) { + return x && x['@@transducer/reduced'] ? x : { + '@@transducer/value': x, + '@@transducer/reduced': true + }; + }; + + /** + * An optimized, private array `slice` implementation. + * + * @private + * @param {Arguments|Array} args The array or arguments object to consider. + * @param {Number} [from=0] The array index to slice from, inclusive. + * @param {Number} [to=args.length] The array index to slice to, exclusive. + * @return {Array} A new, sliced array. + * @example + * + * _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3] + * + * var firstThreeArgs = function(a, b, c, d) { + * return _slice(arguments, 0, 3); + * }; + * firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3] + */ + var _slice = function _slice(args, from, to) { + switch (arguments.length) { + case 1: + return _slice(args, 0, args.length); + case 2: + return _slice(args, from, args.length); + default: + var list = []; + var idx = 0; + var len = Math.max(0, Math.min(args.length, to) - from); + while (idx < len) { + list[idx] = args[from + idx]; + idx += 1; + } + return list; + } + }; + + /** + * Polyfill from . + */ + var _toISOString = function () { + var pad = function pad(n) { + return (n < 10 ? '0' : '') + n; + }; + return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) { + return d.toISOString(); + } : function _toISOString(d) { + return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'; + }; + }(); + + var _xdropRepeatsWith = function () { + function XDropRepeatsWith(pred, xf) { + this.xf = xf; + this.pred = pred; + this.lastValue = undefined; + this.seenFirstValue = false; + } + XDropRepeatsWith.prototype['@@transducer/init'] = function () { + return this.xf['@@transducer/init'](); + }; + XDropRepeatsWith.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](result); + }; + XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) { + var sameAsLast = false; + if (!this.seenFirstValue) { + this.seenFirstValue = true; + } else if (this.pred(this.lastValue, input)) { + sameAsLast = true; + } + this.lastValue = input; + return sameAsLast ? result : this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdropRepeatsWith(pred, xf) { + return new XDropRepeatsWith(pred, xf); + }); + }(); + + var _xfBase = { + init: function () { + return this.xf['@@transducer/init'](); + }, + result: function (result) { + return this.xf['@@transducer/result'](result); + } + }; + + var _xfilter = function () { + function XFilter(f, xf) { + this.xf = xf; + this.f = f; + } + XFilter.prototype['@@transducer/init'] = _xfBase.init; + XFilter.prototype['@@transducer/result'] = _xfBase.result; + XFilter.prototype['@@transducer/step'] = function (result, input) { + return this.f(input) ? this.xf['@@transducer/step'](result, input) : result; + }; + return _curry2(function _xfilter(f, xf) { + return new XFilter(f, xf); + }); + }(); + + var _xfind = function () { + function XFind(f, xf) { + this.xf = xf; + this.f = f; + this.found = false; + } + XFind.prototype['@@transducer/init'] = _xfBase.init; + XFind.prototype['@@transducer/result'] = function (result) { + if (!this.found) { + result = this.xf['@@transducer/step'](result, void 0); + } + return this.xf['@@transducer/result'](result); + }; + XFind.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.found = true; + result = _reduced(this.xf['@@transducer/step'](result, input)); + } + return result; + }; + return _curry2(function _xfind(f, xf) { + return new XFind(f, xf); + }); + }(); + + var _xfindIndex = function () { + function XFindIndex(f, xf) { + this.xf = xf; + this.f = f; + this.idx = -1; + this.found = false; + } + XFindIndex.prototype['@@transducer/init'] = _xfBase.init; + XFindIndex.prototype['@@transducer/result'] = function (result) { + if (!this.found) { + result = this.xf['@@transducer/step'](result, -1); + } + return this.xf['@@transducer/result'](result); + }; + XFindIndex.prototype['@@transducer/step'] = function (result, input) { + this.idx += 1; + if (this.f(input)) { + this.found = true; + result = _reduced(this.xf['@@transducer/step'](result, this.idx)); + } + return result; + }; + return _curry2(function _xfindIndex(f, xf) { + return new XFindIndex(f, xf); + }); + }(); + + var _xfindLast = function () { + function XFindLast(f, xf) { + this.xf = xf; + this.f = f; + } + XFindLast.prototype['@@transducer/init'] = _xfBase.init; + XFindLast.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last)); + }; + XFindLast.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.last = input; + } + return result; + }; + return _curry2(function _xfindLast(f, xf) { + return new XFindLast(f, xf); + }); + }(); + + var _xfindLastIndex = function () { + function XFindLastIndex(f, xf) { + this.xf = xf; + this.f = f; + this.idx = -1; + this.lastIdx = -1; + } + XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init; + XFindLastIndex.prototype['@@transducer/result'] = function (result) { + return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx)); + }; + XFindLastIndex.prototype['@@transducer/step'] = function (result, input) { + this.idx += 1; + if (this.f(input)) { + this.lastIdx = this.idx; + } + return result; + }; + return _curry2(function _xfindLastIndex(f, xf) { + return new XFindLastIndex(f, xf); + }); + }(); + + var _xmap = function () { + function XMap(f, xf) { + this.xf = xf; + this.f = f; + } + XMap.prototype['@@transducer/init'] = _xfBase.init; + XMap.prototype['@@transducer/result'] = _xfBase.result; + XMap.prototype['@@transducer/step'] = function (result, input) { + return this.xf['@@transducer/step'](result, this.f(input)); + }; + return _curry2(function _xmap(f, xf) { + return new XMap(f, xf); + }); + }(); + + var _xtake = function () { + function XTake(n, xf) { + this.xf = xf; + this.n = n; + } + XTake.prototype['@@transducer/init'] = _xfBase.init; + XTake.prototype['@@transducer/result'] = _xfBase.result; + XTake.prototype['@@transducer/step'] = function (result, input) { + if (this.n === 0) { + return _reduced(result); + } else { + this.n -= 1; + return this.xf['@@transducer/step'](result, input); + } + }; + return _curry2(function _xtake(n, xf) { + return new XTake(n, xf); + }); + }(); + + var _xtakeWhile = function () { + function XTakeWhile(f, xf) { + this.xf = xf; + this.f = f; + } + XTakeWhile.prototype['@@transducer/init'] = _xfBase.init; + XTakeWhile.prototype['@@transducer/result'] = _xfBase.result; + XTakeWhile.prototype['@@transducer/step'] = function (result, input) { + return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result); + }; + return _curry2(function _xtakeWhile(f, xf) { + return new XTakeWhile(f, xf); + }); + }(); + + var _xwrap = function () { + function XWrap(fn) { + this.f = fn; + } + XWrap.prototype['@@transducer/init'] = function () { + throw new Error('init not implemented on XWrap'); + }; + XWrap.prototype['@@transducer/result'] = function (acc) { + return acc; + }; + XWrap.prototype['@@transducer/step'] = function (acc, x) { + return this.f(acc, x); + }; + return function _xwrap(fn) { + return new XWrap(fn); + }; + }(); + + /** + * Adds two numbers. Equivalent to `a + b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a + * @param {Number} b + * @return {Number} + * @see R.subtract + * @example + * + * R.add(2, 3); //=> 5 + * R.add(7)(10); //=> 17 + */ + var add = _curry2(function add(a, b) { + return a + b; + }); + + /** + * Applies a function to the value at the given index of an array, + * returning a new copy of the array with the element at the given + * index replaced with the result of the function application. + * @see R.update + * + * @func + * @memberOf R + * @category List + * @sig (a -> a) -> Number -> [a] -> [a] + * @param {Function} fn The function to apply. + * @param {Number} idx The index. + * @param {Array|Arguments} list An array-like object whose value + * at the supplied index will be replaced. + * @return {Array} A copy of the supplied array-like object with + * the element at index `idx` replaced with the value + * returned by applying `fn` to the existing element. + * @example + * + * R.adjust(R.add(10), 1, [0, 1, 2]); //=> [0, 11, 2] + * R.adjust(R.add(10))(1)([0, 1, 2]); //=> [0, 11, 2] + */ + var adjust = _curry3(function adjust(fn, idx, list) { + if (idx >= list.length || idx < -list.length) { + return list; + } + var start = idx < 0 ? list.length : 0; + var _idx = start + idx; + var _list = _concat(list); + _list[_idx] = fn(list[_idx]); + return _list; + }); + + /** + * Returns a function that always returns the given value. Note that for + * non-primitives the value returned is a reference to the original value. + * + * This function is known as `const`, `constant`, or `K` (for K combinator) + * in other languages and libraries. + * + * @func + * @memberOf R + * @category Function + * @sig a -> (* -> a) + * @param {*} val The value to wrap in a function + * @return {Function} A Function :: * -> val. + * @example + * + * var t = R.always('Tee'); + * t(); //=> 'Tee' + */ + var always = _curry1(function always(val) { + return function () { + return val; + }; + }); + + /** + * Returns a new list, composed of n-tuples of consecutive elements + * If `n` is greater than the length of the list, an empty list is returned. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [[a]] + * @param {Number} n The size of the tuples to create + * @param {Array} list The list to split into `n`-tuples + * @return {Array} The new list. + * @example + * + * R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]] + * R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]] + * R.aperture(7, [1, 2, 3, 4, 5]); //=> [] + */ + var aperture = _curry2(function aperture(n, list) { + var idx = 0; + var limit = list.length - (n - 1); + var acc = new Array(limit >= 0 ? limit : 0); + while (idx < limit) { + acc[idx] = _slice(list, idx, idx + n); + idx += 1; + } + return acc; + }); + + /** + * Returns a new list containing the contents of the given list, followed by the given + * element. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The element to add to the end of the new list. + * @param {Array} list The list whose contents will be added to the beginning of the output + * list. + * @return {Array} A new list containing the contents of the old list followed by `el`. + * @see R.prepend + * @example + * + * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests'] + * R.append('tests', []); //=> ['tests'] + * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] + */ + var append = _curry2(function append(el, list) { + return _concat(list, [el]); + }); + + /** + * Applies function `fn` to the argument list `args`. This is useful for + * creating a fixed-arity function from a variadic function. `fn` should + * be a bound function if context is significant. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a) -> [*] -> a + * @param {Function} fn + * @param {Array} args + * @return {*} + * @see R.call, R.unapply + * @example + * + * var nums = [1, 2, 3, -99, 42, 6, 7]; + * R.apply(Math.max, nums); //=> 42 + */ + var apply = _curry2(function apply(fn, args) { + return fn.apply(this, args); + }); + + /** + * Makes a shallow clone of an object, setting or overriding the specified + * property with the given value. Note that this copies and flattens + * prototype properties onto the new object as well. All non-primitive + * properties are copied by reference. + * + * @func + * @memberOf R + * @category Object + * @sig String -> a -> {k: v} -> {k: v} + * @param {String} prop the property name to set + * @param {*} val the new value + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original except for the specified property. + * @see R.dissoc + * @example + * + * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3} + */ + var assoc = _curry3(function assoc(prop, val, obj) { + var result = {}; + for (var p in obj) { + result[p] = obj[p]; + } + result[prop] = val; + return result; + }); + + /** + * Makes a shallow clone of an object, setting or overriding the nodes + * required to create the given path, and placing the specific value at the + * tail end of that path. Note that this copies and flattens prototype + * properties onto the new object as well. All non-primitive properties + * are copied by reference. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> a -> {k: v} -> {k: v} + * @param {Array} path the path to set + * @param {*} val the new value + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original except along the specified path. + * @see R.dissocPath + * @example + * + * R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}} + */ + var assocPath = _curry3(function assocPath(path, val, obj) { + switch (path.length) { + case 0: + return obj; + case 1: + return assoc(path[0], val, obj); + default: + return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj); + } + }); + + /** + * Creates a function that is bound to a context. + * Note: `R.bind` does not provide the additional argument-binding capabilities of + * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind). + * + * @func + * @memberOf R + * @category Function + * @category Object + * @see R.partial + * @sig (* -> *) -> {*} -> (* -> *) + * @param {Function} fn The function to bind to context + * @param {Object} thisObj The context to bind `fn` to + * @return {Function} A function that will execute in the context of `thisObj`. + */ + var bind = _curry2(function bind(fn, thisObj) { + return _arity(fn.length, function () { + return fn.apply(thisObj, arguments); + }); + }); + + /** + * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first + * function if it is false-y and the result of the second function otherwise. Note that this is + * short-circuited, meaning that the second function will not be invoked if the first returns a false-y + * value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) + * @param {Function} f a predicate + * @param {Function} g another predicate + * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together. + * @see R.and + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0 }; + * var f = R.both(gt10, even); + * f(100); //=> true + * f(101); //=> false + */ + var both = _curry2(function both(f, g) { + return function _both() { + return f.apply(this, arguments) && g.apply(this, arguments); + }; + }); + + /** + * Makes a comparator function out of a function that reports whether the first element is less than the second. + * + * @func + * @memberOf R + * @category Function + * @sig (a, b -> Boolean) -> (a, b -> Number) + * @param {Function} pred A predicate function of arity two. + * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`. + * @example + * + * var cmp = R.comparator(function(a, b) { + * return a.age < b.age; + * }); + * var people = [ + * // ... + * ]; + * R.sort(cmp, people); + */ + var comparator = _curry1(function comparator(pred) { + return function (a, b) { + return pred(a, b) ? -1 : pred(b, a) ? 1 : 0; + }; + }); + + /** + * Takes a function `f` and returns a function `g` such that: + * + * - applying `g` to zero or more arguments will give __true__ if applying + * the same arguments to `f` gives a logical __false__ value; and + * + * - applying `g` to zero or more arguments will give __false__ if applying + * the same arguments to `f` gives a logical __true__ value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> *) -> (*... -> Boolean) + * @param {Function} f + * @return {Function} + * @see R.not + * @example + * + * var isEven = function(n) { return n % 2 === 0; }; + * var isOdd = R.complement(isEven); + * isOdd(21); //=> true + * isOdd(42); //=> false + */ + var complement = _curry1(_complement); + + /** + * Returns a function, `fn`, which encapsulates if/else-if/else logic. + * `R.cond` takes a list of [predicate, transform] pairs. All of the + * arguments to `fn` are applied to each of the predicates in turn + * until one returns a "truthy" value, at which point `fn` returns the + * result of applying its arguments to the corresponding transformer. + * If none of the predicates matches, `fn` returns undefined. + * + * @func + * @memberOf R + * @category Logic + * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *) + * @param {Array} pairs + * @return {Function} + * @example + * + * var fn = R.cond([ + * [R.equals(0), R.always('water freezes at 0°C')], + * [R.equals(100), R.always('water boils at 100°C')], + * [R.T, function(temp) { return 'nothing special happens at ' + temp + '°C'; }] + * ]); + * fn(0); //=> 'water freezes at 0°C' + * fn(50); //=> 'nothing special happens at 50°C' + * fn(100); //=> 'water boils at 100°C' + */ + var cond = _curry1(function cond(pairs) { + return function () { + var idx = 0; + while (idx < pairs.length) { + if (pairs[idx][0].apply(this, arguments)) { + return pairs[idx][1].apply(this, arguments); + } + idx += 1; + } + }; + }); + + /** + * Returns `true` if the `x` is found in the `list`, using `pred` as an + * equality predicate for `x`. + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> a -> [a] -> Boolean + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {*} x The item to find + * @param {Array} list The list to iterate over + * @return {Boolean} `true` if `x` is in `list`, else `false`. + * @example + * + * var xs = [{x: 12}, {x: 11}, {x: 10}]; + * R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true + * R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false + */ + var containsWith = _curry3(_containsWith); + + /** + * Counts the elements of a list according to how many match each value + * of a key generated by the supplied function. Returns an object + * mapping the keys produced by `fn` to the number of occurrences in + * the list. Note that all keys are coerced to strings because of how + * JavaScript objects work. + * + * @func + * @memberOf R + * @category Relation + * @sig (a -> String) -> [a] -> {*} + * @param {Function} fn The function used to map values to keys. + * @param {Array} list The list to count elements from. + * @return {Object} An object mapping keys to number of occurrences in the list. + * @example + * + * var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2]; + * var letters = R.split('', 'abcABCaaaBBc'); + * R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1} + * R.countBy(R.toLower)(letters); //=> {'a': 5, 'b': 4, 'c': 3} + */ + var countBy = _curry2(function countBy(fn, list) { + var counts = {}; + var len = list.length; + var idx = 0; + while (idx < len) { + var key = fn(list[idx]); + counts[key] = (_has(key, counts) ? counts[key] : 0) + 1; + idx += 1; + } + return counts; + }); + + /** + * Creates an object containing a single key:value pair. + * + * @func + * @memberOf R + * @category Object + * @sig String -> a -> {String:a} + * @param {String} key + * @param {*} val + * @return {Object} + * @example + * + * var matchPhrases = R.compose( + * R.createMapEntry('must'), + * R.map(R.createMapEntry('match_phrase')) + * ); + * matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]} + */ + var createMapEntry = _curry2(function createMapEntry(key, val) { + var obj = {}; + obj[key] = val; + return obj; + }); + + /** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ + var curryN = _curry2(function curryN(length, fn) { + if (length === 1) { + return _curry1(fn); + } + return _arity(length, _curryN(length, [], fn)); + }); + + /** + * Decrements its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @see R.inc + * @example + * + * R.dec(42); //=> 41 + */ + var dec = add(-1); + + /** + * Returns the second argument if it is not null or undefined. If it is null + * or undefined, the first (default) argument is returned. + * + * @func + * @memberOf R + * @category Logic + * @sig a -> b -> a | b + * @param {a} val The default value. + * @param {b} val The value to return if it is not null or undefined + * @return {*} The the second value or the default value + * @example + * + * var defaultTo42 = defaultTo(42); + * + * defaultTo42(null); //=> 42 + * defaultTo42(undefined); //=> 42 + * defaultTo42('Ramda'); //=> 'Ramda' + */ + var defaultTo = _curry2(function defaultTo(d, v) { + return v == null ? d : v; + }); + + /** + * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. + * Duplication is determined according to the value returned by applying the supplied predicate to two list + * elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @see R.difference + * @return {Array} The elements in `list1` that are not in `list2`. + * @example + * + * function cmp(x, y) { return x.a === y.a; } + * var l1 = [{a: 1}, {a: 2}, {a: 3}]; + * var l2 = [{a: 3}, {a: 4}]; + * R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}] + */ + var differenceWith = _curry3(function differenceWith(pred, first, second) { + var out = []; + var idx = 0; + var firstLen = first.length; + var containsPred = containsWith(pred); + while (idx < firstLen) { + if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) { + out[out.length] = first[idx]; + } + idx += 1; + } + return out; + }); + + /** + * Returns a new object that does not contain a `prop` property. + * + * @func + * @memberOf R + * @category Object + * @sig String -> {k: v} -> {k: v} + * @param {String} prop the name of the property to dissociate + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original but without the specified property + * @see R.assoc + * @example + * + * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} + */ + var dissoc = _curry2(function dissoc(prop, obj) { + var result = {}; + for (var p in obj) { + if (p !== prop) { + result[p] = obj[p]; + } + } + return result; + }); + + /** + * Makes a shallow clone of an object, omitting the property at the + * given path. Note that this copies and flattens prototype properties + * onto the new object as well. All non-primitive properties are copied + * by reference. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {k: v} -> {k: v} + * @param {Array} path the path to set + * @param {Object} obj the object to clone + * @return {Object} a new object without the property at path + * @see R.assocPath + * @example + * + * R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}} + */ + var dissocPath = _curry2(function dissocPath(path, obj) { + switch (path.length) { + case 0: + return obj; + case 1: + return dissoc(path[0], obj); + default: + var head = path[0]; + var tail = _slice(path, 1); + return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj); + } + }); + + /** + * Divides two numbers. Equivalent to `a / b`. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a / b`. + * @see R.multiply + * @example + * + * R.divide(71, 100); //=> 0.71 + * + * var half = R.divide(R.__, 2); + * half(42); //=> 21 + * + * var reciprocal = R.divide(1); + * reciprocal(4); //=> 0.25 + */ + var divide = _curry2(function divide(a, b) { + return a / b; + }); + + /** + * Returns a new list containing all but last the`n` elements of a given list, + * passing each value from the right to the supplied predicate function, skipping + * elements while the predicate function returns `true`. The predicate function + * is passed one argument: (value)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.takeLastWhile + * @example + * + * var lteThree = function(x) { + * return x <= 3; + * }; + * + * R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2] + */ + var dropLastWhile = _curry2(function dropLastWhile(pred, list) { + var idx = list.length - 1; + while (idx >= 0 && pred(list[idx])) { + idx -= 1; + } + return _slice(list, 0, idx + 1); + }); + + /** + * A function wrapping calls to the two functions in an `||` operation, returning the result of the first + * function if it is truth-y and the result of the second function otherwise. Note that this is + * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y + * value. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) + * @param {Function} f a predicate + * @param {Function} g another predicate + * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together. + * @see R.or + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0 }; + * var f = R.either(gt10, even); + * f(101); //=> true + * f(8); //=> true + */ + var either = _curry2(function either(f, g) { + return function _either() { + return f.apply(this, arguments) || g.apply(this, arguments); + }; + }); + + /** + * Returns the empty value of its argument's type. Ramda defines the empty + * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are + * supported if they define `.empty` and/or `.prototype.empty`. + * + * @func + * @memberOf R + * @category Function + * @sig a -> a + * @param {*} x + * @return {*} + * @example + * + * R.empty(Just(42)); //=> Nothing() + * R.empty([1, 2, 3]); //=> [] + * R.empty('unicorns'); //=> '' + * R.empty({x: 1, y: 2}); //=> {} + */ + var empty = _curry1(function empty(x) { + if (x != null && typeof x.empty === 'function') { + return x.empty(); + } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') { + return x.constructor.empty(); + } else { + switch (Object.prototype.toString.call(x)) { + case '[object Array]': + return []; + case '[object Object]': + return {}; + case '[object String]': + return ''; + } + } + }); + + /** + * Creates a new object by recursively evolving a shallow copy of `object`, according to the + * `transformation` functions. All non-primitive properties are copied by reference. + * + * A `tranformation` function will not be invoked if its corresponding key does not exist in + * the evolved object. + * + * @func + * @memberOf R + * @category Object + * @sig {k: (v -> v)} -> {k: v} -> {k: v} + * @param {Object} transformations The object specifying transformation functions to apply + * to the object. + * @param {Object} object The object to be transformed. + * @return {Object} The transformed object. + * @example + * + * var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123}; + * var transformations = { + * firstName: R.trim, + * lastName: R.trim, // Will not get invoked. + * data: {elapsed: R.add(1), remaining: R.add(-1)} + * }; + * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} + */ + var evolve = _curry2(function evolve(transformations, object) { + var transformation, key, type, result = {}; + for (key in object) { + transformation = transformations[key]; + type = typeof transformation; + result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key]; + } + return result; + }); + + /** + * Creates a new object out of a list key-value pairs. + * + * @func + * @memberOf R + * @category List + * @sig [[k,v]] -> {k: v} + * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object. + * @return {Object} The object made by pairing up `keys` and `values`. + * @see R.toPairs + * @example + * + * R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3} + */ + var fromPairs = _curry1(function fromPairs(pairs) { + var idx = 0, len = pairs.length, out = {}; + while (idx < len) { + if (_isArray(pairs[idx]) && pairs[idx].length) { + out[pairs[idx][0]] = pairs[idx][1]; + } + idx += 1; + } + return out; + }); + + /** + * Returns `true` if the first argument is greater than the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @see R.lt + * @example + * + * R.gt(2, 1); //=> true + * R.gt(2, 2); //=> false + * R.gt(2, 3); //=> false + * R.gt('a', 'z'); //=> false + * R.gt('z', 'a'); //=> true + */ + var gt = _curry2(function gt(a, b) { + return a > b; + }); + + /** + * Returns `true` if the first argument is greater than or equal to the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {Number} a + * @param {Number} b + * @return {Boolean} + * @see R.lte + * @example + * + * R.gte(2, 1); //=> true + * R.gte(2, 2); //=> true + * R.gte(2, 3); //=> false + * R.gte('a', 'z'); //=> false + * R.gte('z', 'a'); //=> true + */ + var gte = _curry2(function gte(a, b) { + return a >= b; + }); + + /** + * Returns whether or not an object has an own property with + * the specified name + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: x} -> Boolean + * @param {String} prop The name of the property to check for. + * @param {Object} obj The object to query. + * @return {Boolean} Whether the property exists. + * @example + * + * var hasName = R.has('name'); + * hasName({name: 'alice'}); //=> true + * hasName({name: 'bob'}); //=> true + * hasName({}); //=> false + * + * var point = {x: 0, y: 0}; + * var pointHas = R.has(R.__, point); + * pointHas('x'); //=> true + * pointHas('y'); //=> true + * pointHas('z'); //=> false + */ + var has = _curry2(_has); + + /** + * Returns whether or not an object or its prototype chain has + * a property with the specified name + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: x} -> Boolean + * @param {String} prop The name of the property to check for. + * @param {Object} obj The object to query. + * @return {Boolean} Whether the property exists. + * @example + * + * function Rectangle(width, height) { + * this.width = width; + * this.height = height; + * } + * Rectangle.prototype.area = function() { + * return this.width * this.height; + * }; + * + * var square = new Rectangle(2, 2); + * R.hasIn('width', square); //=> true + * R.hasIn('area', square); //=> true + */ + var hasIn = _curry2(function hasIn(prop, obj) { + return prop in obj; + }); + + /** + * Returns true if its arguments are identical, false otherwise. Values are + * identical if they reference the same memory. `NaN` is identical to `NaN`; + * `0` and `-0` are not identical. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * var o = {}; + * R.identical(o, o); //=> true + * R.identical(1, 1); //=> true + * R.identical(1, '1'); //=> false + * R.identical([], []); //=> false + * R.identical(0, -0); //=> false + * R.identical(NaN, NaN); //=> true + */ + // SameValue algorithm + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + // Step 6.a: NaN == NaN + var identical = _curry2(function identical(a, b) { + // SameValue algorithm + if (a === b) { + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + return a !== 0 || 1 / a === 1 / b; + } else { + // Step 6.a: NaN == NaN + return a !== a && b !== b; + } + }); + + /** + * A function that does nothing but return the parameter supplied to it. Good as a default + * or placeholder function. + * + * @func + * @memberOf R + * @category Function + * @sig a -> a + * @param {*} x The value to return. + * @return {*} The input value, `x`. + * @example + * + * R.identity(1); //=> 1 + * + * var obj = {}; + * R.identity(obj) === obj; //=> true + */ + var identity = _curry1(_identity); + + /** + * Creates a function that will process either the `onTrue` or the `onFalse` function depending + * upon the result of the `condition` predicate. + * + * @func + * @memberOf R + * @category Logic + * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *) + * @param {Function} condition A predicate function + * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value. + * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value. + * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse` + * function depending upon the result of the `condition` predicate. + * @example + * + * // Flatten all arrays in the list but leave other values alone. + * var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity)); + * + * flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}] + * flattenArrays([[[10], 123], [8, [10]], "hello"]); //=> [[10, 123], [8, 10], "hello"] + */ + var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) { + return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() { + return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments); + }); + }); + + /** + * Increments its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @see R.dec + * @example + * + * R.inc(42); //=> 43 + */ + var inc = add(1); + + /** + * Inserts the supplied element into the list, at index `index`. _Note + * that this is not destructive_: it returns a copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> a -> [a] -> [a] + * @param {Number} index The position to insert the element + * @param {*} elt The element to insert into the Array + * @param {Array} list The list to insert into + * @return {Array} A new Array with `elt` inserted at `index`. + * @example + * + * R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4] + */ + var insert = _curry3(function insert(idx, elt, list) { + idx = idx < list.length && idx >= 0 ? idx : list.length; + var result = _slice(list); + result.splice(idx, 0, elt); + return result; + }); + + /** + * Inserts the sub-list into the list, at index `index`. _Note that this + * is not destructive_: it returns a copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] -> [a] + * @param {Number} index The position to insert the sub-list + * @param {Array} elts The sub-list to insert into the Array + * @param {Array} list The list to insert the sub-list into + * @return {Array} A new Array with `elts` inserted starting at `index`. + * @example + * + * R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4] + */ + var insertAll = _curry3(function insertAll(idx, elts, list) { + idx = idx < list.length && idx >= 0 ? idx : list.length; + return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx)); + }); + + /** + * See if an object (`val`) is an instance of the supplied constructor. + * This function will check up the inheritance chain, if any. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> a -> Boolean + * @param {Object} ctor A constructor + * @param {*} val The value to test + * @return {Boolean} + * @example + * + * R.is(Object, {}); //=> true + * R.is(Number, 1); //=> true + * R.is(Object, 1); //=> false + * R.is(String, 's'); //=> true + * R.is(String, new String('')); //=> true + * R.is(Object, new String('')); //=> true + * R.is(Object, 's'); //=> false + * R.is(Number, {}); //=> false + */ + var is = _curry2(function is(Ctor, val) { + return val != null && val.constructor === Ctor || val instanceof Ctor; + }); + + /** + * Tests whether or not an object is similar to an array. + * + * @func + * @memberOf R + * @category Type + * @category List + * @sig * -> Boolean + * @param {*} x The object to test. + * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise. + * @example + * + * R.isArrayLike([]); //=> true + * R.isArrayLike(true); //=> false + * R.isArrayLike({}); //=> false + * R.isArrayLike({length: 10}); //=> false + * R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true + */ + var isArrayLike = _curry1(function isArrayLike(x) { + if (_isArray(x)) { + return true; + } + if (!x) { + return false; + } + if (typeof x !== 'object') { + return false; + } + if (x instanceof String) { + return false; + } + if (x.nodeType === 1) { + return !!x.length; + } + if (x.length === 0) { + return true; + } + if (x.length > 0) { + return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1); + } + return false; + }); + + /** + * Reports whether the list has zero elements. + * + * @func + * @memberOf R + * @category Logic + * @sig [a] -> Boolean + * @param {Array} list + * @return {Boolean} + * @example + * + * R.isEmpty([1, 2, 3]); //=> false + * R.isEmpty([]); //=> true + * R.isEmpty(''); //=> true + * R.isEmpty(null); //=> false + * R.isEmpty(R.keys({})); //=> true + * R.isEmpty({}); //=> false ({} does not have a length property) + * R.isEmpty({length: 0}); //=> true + */ + var isEmpty = _curry1(function isEmpty(list) { + return Object(list).length === 0; + }); + + /** + * Checks if the input value is `null` or `undefined`. + * + * @func + * @memberOf R + * @category Type + * @sig * -> Boolean + * @param {*} x The value to test. + * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`. + * @example + * + * R.isNil(null); //=> true + * R.isNil(undefined); //=> true + * R.isNil(0); //=> false + * R.isNil([]); //=> false + */ + var isNil = _curry1(function isNil(x) { + return x == null; + }); + + /** + * Returns a list containing the names of all the enumerable own + * properties of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own properties. + * @example + * + * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] + */ + // cover IE < 9 keys issues + var keys = function () { + // cover IE < 9 keys issues + var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString'); + var nonEnumerableProps = [ + 'constructor', + 'valueOf', + 'isPrototypeOf', + 'toString', + 'propertyIsEnumerable', + 'hasOwnProperty', + 'toLocaleString' + ]; + var contains = function contains(list, item) { + var idx = 0; + while (idx < list.length) { + if (list[idx] === item) { + return true; + } + idx += 1; + } + return false; + }; + return typeof Object.keys === 'function' ? _curry1(function keys(obj) { + return Object(obj) !== obj ? [] : Object.keys(obj); + }) : _curry1(function keys(obj) { + if (Object(obj) !== obj) { + return []; + } + var prop, ks = [], nIdx; + for (prop in obj) { + if (_has(prop, obj)) { + ks[ks.length] = prop; + } + } + if (hasEnumBug) { + nIdx = nonEnumerableProps.length - 1; + while (nIdx >= 0) { + prop = nonEnumerableProps[nIdx]; + if (_has(prop, obj) && !contains(ks, prop)) { + ks[ks.length] = prop; + } + nIdx -= 1; + } + } + return ks; + }); + }(); + + /** + * Returns a list containing the names of all the + * properties of the supplied object, including prototype properties. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.keysIn(f); //=> ['x', 'y'] + */ + var keysIn = _curry1(function keysIn(obj) { + var prop, ks = []; + for (prop in obj) { + ks[ks.length] = prop; + } + return ks; + }); + + /** + * Returns the number of elements in the array by returning `list.length`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> Number + * @param {Array} list The array to inspect. + * @return {Number} The length of the array. + * @example + * + * R.length([]); //=> 0 + * R.length([1, 2, 3]); //=> 3 + */ + var length = _curry1(function length(list) { + return list != null && is(Number, list.length) ? list.length : NaN; + }); + + /** + * Returns `true` if the first argument is less than the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @see R.gt + * @example + * + * R.lt(2, 1); //=> false + * R.lt(2, 2); //=> false + * R.lt(2, 3); //=> true + * R.lt('a', 'z'); //=> true + * R.lt('z', 'a'); //=> false + */ + var lt = _curry2(function lt(a, b) { + return a < b; + }); + + /** + * Returns `true` if the first argument is less than or equal to the second; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> Boolean + * @param {Number} a + * @param {Number} b + * @return {Boolean} + * @see R.gte + * @example + * + * R.lte(2, 1); //=> false + * R.lte(2, 2); //=> true + * R.lte(2, 3); //=> true + * R.lte('a', 'z'); //=> true + * R.lte('z', 'a'); //=> false + */ + var lte = _curry2(function lte(a, b) { + return a <= b; + }); + + /** + * The mapAccum function behaves like a combination of map and reduce; it applies a + * function to each element of a list, passing an accumulating parameter from left to + * right, and returning a final value of this accumulator together with the new list. + * + * The iterator function receives two arguments, *acc* and *value*, and should return + * a tuple *[acc, value]*. + * + * @func + * @memberOf R + * @category List + * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var digits = ['1', '2', '3', '4']; + * var append = function(a, b) { + * return [a + b, a + b]; + * } + * + * R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']] + */ + var mapAccum = _curry3(function mapAccum(fn, acc, list) { + var idx = 0, len = list.length, result = [], tuple = [acc]; + while (idx < len) { + tuple = fn(tuple[0], list[idx]); + result[idx] = tuple[1]; + idx += 1; + } + return [ + tuple[0], + result + ]; + }); + + /** + * The mapAccumRight function behaves like a combination of map and reduce; it applies a + * function to each element of a list, passing an accumulating parameter from right + * to left, and returning a final value of this accumulator together with the new list. + * + * Similar to `mapAccum`, except moves through the input list from the right to the + * left. + * + * The iterator function receives two arguments, *acc* and *value*, and should return + * a tuple *[acc, value]*. + * + * @func + * @memberOf R + * @category List + * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var digits = ['1', '2', '3', '4']; + * var append = function(a, b) { + * return [a + b, a + b]; + * } + * + * R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']] + */ + var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) { + var idx = list.length - 1, result = [], tuple = [acc]; + while (idx >= 0) { + tuple = fn(tuple[0], list[idx]); + result[idx] = tuple[1]; + idx -= 1; + } + return [ + tuple[0], + result + ]; + }); + + /** + * Tests a regular expression against a String. Note that this function + * will return an empty array when there are no matches. This differs + * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) + * which returns `null` when there are no matches. + * + * @func + * @memberOf R + * @see R.test + * @category String + * @sig RegExp -> String -> [String | Undefined] + * @param {RegExp} rx A regular expression. + * @param {String} str The string to match against + * @return {Array} The list of matches or empty array. + * @example + * + * R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na'] + * R.match(/a/, 'b'); //=> [] + * R.match(/a/, null); //=> TypeError: null does not have a method named "match" + */ + var match = _curry2(function match(rx, str) { + return str.match(rx) || []; + }); + + /** + * mathMod behaves like the modulo operator should mathematically, unlike the `%` + * operator (and by extension, R.modulo). So while "-17 % 5" is -2, + * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN + * when the modulus is zero or negative. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} m The dividend. + * @param {Number} p the modulus. + * @return {Number} The result of `b mod a`. + * @example + * + * R.mathMod(-17, 5); //=> 3 + * R.mathMod(17, 5); //=> 2 + * R.mathMod(17, -5); //=> NaN + * R.mathMod(17, 0); //=> NaN + * R.mathMod(17.2, 5); //=> NaN + * R.mathMod(17, 5.3); //=> NaN + * + * var clock = R.mathMod(R.__, 12); + * clock(15); //=> 3 + * clock(24); //=> 0 + * + * var seventeenMod = R.mathMod(17); + * seventeenMod(3); //=> 2 + * seventeenMod(4); //=> 1 + * seventeenMod(10); //=> 7 + */ + var mathMod = _curry2(function mathMod(m, p) { + if (!_isInteger(m)) { + return NaN; + } + if (!_isInteger(p) || p < 1) { + return NaN; + } + return (m % p + p) % p; + }); + + /** + * Returns the larger of its two arguments. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> a + * @param {*} a + * @param {*} b + * @return {*} + * @see R.maxBy, R.min + * @example + * + * R.max(789, 123); //=> 789 + * R.max('a', 'b'); //=> 'b' + */ + var max = _curry2(function max(a, b) { + return b > a ? b : a; + }); + + /** + * Takes a function and two values, and returns whichever value produces + * the larger result when passed to the provided function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> a -> a -> a + * @param {Function} f + * @param {*} a + * @param {*} b + * @return {*} + * @see R.max, R.minBy + * @example + * + * R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3 + */ + var maxBy = _curry3(function maxBy(f, a, b) { + return f(b) > f(a) ? b : a; + }); + + /** + * Create a new object with the own properties of `a` + * merged with the own properties of object `b`. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> {k: v} -> {k: v} + * @param {Object} a + * @param {Object} b + * @return {Object} + * @example + * + * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); + * //=> { 'name': 'fred', 'age': 40 } + * + * var resetToDefault = R.merge(R.__, {x: 0}); + * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} + */ + var merge = _curry2(function merge(a, b) { + var result = {}; + var ks = keys(a); + var idx = 0; + while (idx < ks.length) { + result[ks[idx]] = a[ks[idx]]; + idx += 1; + } + ks = keys(b); + idx = 0; + while (idx < ks.length) { + result[ks[idx]] = b[ks[idx]]; + idx += 1; + } + return result; + }); + + /** + * Returns the smaller of its two arguments. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord a => a -> a -> a + * @param {*} a + * @param {*} b + * @return {*} + * @see R.minBy, R.max + * @example + * + * R.min(789, 123); //=> 123 + * R.min('a', 'b'); //=> 'a' + */ + var min = _curry2(function min(a, b) { + return b < a ? b : a; + }); + + /** + * Takes a function and two values, and returns whichever value produces + * the smaller result when passed to the provided function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> a -> a -> a + * @param {Function} f + * @param {*} a + * @param {*} b + * @return {*} + * @see R.min, R.maxBy + * @example + * + * R.minBy(function(n) { return n * n; }, -3, 2); //=> 2 + */ + var minBy = _curry3(function minBy(f, a, b) { + return f(b) < f(a) ? b : a; + }); + + /** + * Divides the second parameter by the first and returns the remainder. + * Note that this functions preserves the JavaScript-style behavior for + * modulo. For mathematical modulo see `mathMod` + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The value to the divide. + * @param {Number} b The pseudo-modulus + * @return {Number} The result of `b % a`. + * @see R.mathMod + * @example + * + * R.modulo(17, 3); //=> 2 + * // JS behavior: + * R.modulo(-17, 3); //=> -2 + * R.modulo(17, -3); //=> 2 + * + * var isOdd = R.modulo(R.__, 2); + * isOdd(42); //=> 0 + * isOdd(21); //=> 1 + */ + var modulo = _curry2(function modulo(a, b) { + return a % b; + }); + + /** + * Multiplies two numbers. Equivalent to `a * b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a * b`. + * @see R.divide + * @example + * + * var double = R.multiply(2); + * var triple = R.multiply(3); + * double(3); //=> 6 + * triple(4); //=> 12 + * R.multiply(2, 5); //=> 10 + */ + var multiply = _curry2(function multiply(a, b) { + return a * b; + }); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly `n` + * parameters. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} n The desired arity of the new function. + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity `n`. + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.nAry(1, takesTwoArgs); + * takesOneArg.length; //=> 1 + * // Only `n` arguments are passed to the wrapped function + * takesOneArg(1, 2); //=> [1, undefined] + */ + var nAry = _curry2(function nAry(n, fn) { + switch (n) { + case 0: + return function () { + return fn.call(this); + }; + case 1: + return function (a0) { + return fn.call(this, a0); + }; + case 2: + return function (a0, a1) { + return fn.call(this, a0, a1); + }; + case 3: + return function (a0, a1, a2) { + return fn.call(this, a0, a1, a2); + }; + case 4: + return function (a0, a1, a2, a3) { + return fn.call(this, a0, a1, a2, a3); + }; + case 5: + return function (a0, a1, a2, a3, a4) { + return fn.call(this, a0, a1, a2, a3, a4); + }; + case 6: + return function (a0, a1, a2, a3, a4, a5) { + return fn.call(this, a0, a1, a2, a3, a4, a5); + }; + case 7: + return function (a0, a1, a2, a3, a4, a5, a6) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6); + }; + case 8: + return function (a0, a1, a2, a3, a4, a5, a6, a7) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7); + }; + case 9: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8); + }; + case 10: + return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + }; + default: + throw new Error('First argument to nAry must be a non-negative integer no greater than ten'); + } + }); + + /** + * Negates its argument. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number + * @param {Number} n + * @return {Number} + * @example + * + * R.negate(42); //=> -42 + */ + var negate = _curry1(function negate(n) { + return -n; + }); + + /** + * A function that returns the `!` of its argument. It will return `true` when + * passed false-y value, and `false` when passed a truth-y one. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> Boolean + * @param {*} a any value + * @return {Boolean} the logical inverse of passed argument. + * @see R.complement + * @example + * + * R.not(true); //=> false + * R.not(false); //=> true + * R.not(0); => true + * R.not(1); => false + */ + var not = _curry1(function not(a) { + return !a; + }); + + /** + * Returns the nth element of the given list or string. + * If n is negative the element at index length + n is returned. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> a | Undefined + * @sig Number -> String -> String + * @param {Number} offset + * @param {*} list + * @return {*} + * @example + * + * var list = ['foo', 'bar', 'baz', 'quux']; + * R.nth(1, list); //=> 'bar' + * R.nth(-1, list); //=> 'quux' + * R.nth(-99, list); //=> undefined + * + * R.nth('abc', 2); //=> 'c' + * R.nth('abc', 3); //=> '' + */ + var nth = _curry2(function nth(offset, list) { + var idx = offset < 0 ? list.length + offset : offset; + return _isString(list) ? list.charAt(idx) : list[idx]; + }); + + /** + * Returns a function which returns its nth argument. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> *... -> * + * @param {Number} n + * @return {Function} + * @example + * + * R.nthArg(1)('a', 'b', 'c'); //=> 'b' + * R.nthArg(-1)('a', 'b', 'c'); //=> 'c' + */ + var nthArg = _curry1(function nthArg(n) { + return function () { + return nth(n, arguments); + }; + }); + + /** + * Returns the nth character of the given string. + * + * @func + * @memberOf R + * @category String + * @sig Number -> String -> String + * @param {Number} n + * @param {String} str + * @return {String} + * @deprecated since v0.16.0 + * @example + * + * R.nthChar(2, 'Ramda'); //=> 'm' + * R.nthChar(-2, 'Ramda'); //=> 'd' + */ + var nthChar = _curry2(function nthChar(n, str) { + return str.charAt(n < 0 ? str.length + n : n); + }); + + /** + * Returns the character code of the nth character of the given string. + * + * @func + * @memberOf R + * @category String + * @sig Number -> String -> Number + * @param {Number} n + * @param {String} str + * @return {Number} + * @deprecated since v0.16.0 + * @example + * + * R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0) + * R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0) + */ + var nthCharCode = _curry2(function nthCharCode(n, str) { + return str.charCodeAt(n < 0 ? str.length + n : n); + }); + + /** + * Returns a singleton array containing the value provided. + * + * Note this `of` is different from the ES6 `of`; See + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of + * + * @func + * @memberOf R + * @category Function + * @sig a -> [a] + * @param {*} x any value + * @return {Array} An array wrapping `x`. + * @example + * + * R.of(null); //=> [null] + * R.of([42]); //=> [[42]] + */ + var of = _curry1(function of(x) { + return [x]; + }); + + /** + * Accepts a function `fn` and returns a function that guards invocation of `fn` such that + * `fn` can only ever be called once, no matter how many times the returned function is + * invoked. + * + * @func + * @memberOf R + * @category Function + * @sig (a... -> b) -> (a... -> b) + * @param {Function} fn The function to wrap in a call-only-once wrapper. + * @return {Function} The wrapped function. + * @example + * + * var addOneOnce = R.once(function(x){ return x + 1; }); + * addOneOnce(10); //=> 11 + * addOneOnce(addOneOnce(50)); //=> 11 + */ + var once = _curry1(function once(fn) { + var called = false, result; + return function () { + if (called) { + return result; + } + called = true; + result = fn.apply(this, arguments); + return result; + }; + }); + + /** + * Returns the result of "setting" the portion of the given data structure + * focused by the given lens to the given value. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> (a -> a) -> s -> s + * @param {Lens} lens + * @param {*} v + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var headLens = R.lensIndex(0); + * + * R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz'] + */ + var over = function () { + var Identity = function (x) { + return { + value: x, + map: function (f) { + return Identity(f(x)); + } + }; + }; + return _curry3(function over(lens, f, x) { + return lens(function (y) { + return Identity(f(y)); + })(x).value; + }); + }(); + + /** + * Retrieve the value at a given path. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {k: v} -> v | Undefined + * @param {Array} path The path to use. + * @return {*} The data at `path`. + * @example + * + * R.path(['a', 'b'], {a: {b: 2}}); //=> 2 + * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined + */ + var path = _curry2(function path(paths, obj) { + if (obj == null) { + return; + } else { + var val = obj; + for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) { + val = val[paths[idx]]; + } + return val; + } + }); + + /** + * Returns a partial copy of an object containing only the keys specified. If the key does not exist, the + * property is ignored. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> {k: v} + * @param {Array} names an array of String property names to copy onto a new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties from `names` on it. + * @see R.omit + * @example + * + * R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} + * R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1} + */ + var pick = _curry2(function pick(names, obj) { + var result = {}; + var idx = 0; + while (idx < names.length) { + if (names[idx] in obj) { + result[names[idx]] = obj[names[idx]]; + } + idx += 1; + } + return result; + }); + + /** + * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> {k: v} + * @param {Array} names an array of String property names to copy onto a new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties from `names` on it. + * @see R.pick + * @example + * + * R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} + * R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined} + */ + var pickAll = _curry2(function pickAll(names, obj) { + var result = {}; + var idx = 0; + var len = names.length; + while (idx < len) { + var name = names[idx]; + result[name] = obj[name]; + idx += 1; + } + return result; + }); + + /** + * Returns a partial copy of an object containing only the keys that + * satisfy the supplied predicate. + * + * @func + * @memberOf R + * @category Object + * @sig (v, k -> Boolean) -> {k: v} -> {k: v} + * @param {Function} pred A predicate to determine whether or not a key + * should be included on the output object. + * @param {Object} obj The object to copy from + * @return {Object} A new object with only properties that satisfy `pred` + * on it. + * @see R.pick + * @example + * + * var isUpperCase = function(val, key) { return key.toUpperCase() === key; } + * R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4} + */ + var pickBy = _curry2(function pickBy(test, obj) { + var result = {}; + for (var prop in obj) { + if (test(obj[prop], prop, obj)) { + result[prop] = obj[prop]; + } + } + return result; + }); + + /** + * Returns a new list with the given element at the front, followed by the contents of the + * list. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The item to add to the head of the output list. + * @param {Array} list The array to add to the tail of the output list. + * @return {Array} A new array. + * @see R.append + * @example + * + * R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum'] + */ + var prepend = _curry2(function prepend(el, list) { + return _concat([el], list); + }); + + /** + * Returns a function that when supplied an object returns the indicated property of that object, if it exists. + * + * @func + * @memberOf R + * @category Object + * @sig s -> {s: a} -> a | Undefined + * @param {String} p The property name + * @param {Object} obj The object to query + * @return {*} The value at `obj.p`. + * @example + * + * R.prop('x', {x: 100}); //=> 100 + * R.prop('x', {}); //=> undefined + */ + var prop = _curry2(function prop(p, obj) { + return obj[p]; + }); + + /** + * If the given, non-null object has an own property with the specified name, + * returns the value of that property. + * Otherwise returns the provided default value. + * + * @func + * @memberOf R + * @category Object + * @sig a -> String -> Object -> a + * @param {*} val The default value. + * @param {String} p The name of the property to return. + * @param {Object} obj The object to query. + * @return {*} The value of given property of the supplied object or the default value. + * @example + * + * var alice = { + * name: 'ALICE', + * age: 101 + * }; + * var favorite = R.prop('favoriteLibrary'); + * var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary'); + * + * favorite(alice); //=> undefined + * favoriteWithDefault(alice); //=> 'Ramda' + */ + var propOr = _curry3(function propOr(val, p, obj) { + return obj != null && _has(p, obj) ? obj[p] : val; + }); + + /** + * Returns `true` if the specified object property satisfies the given + * predicate; `false` otherwise. + * + * @func + * @memberOf R + * @category Logic + * @sig (a -> Boolean) -> String -> {String: a} -> Boolean + * @param {Function} pred + * @param {String} name + * @param {*} obj + * @return {Boolean} + * @see R.propEq + * @see R.propIs + * @example + * + * R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true + */ + var propSatisfies = _curry3(function propSatisfies(pred, name, obj) { + return pred(obj[name]); + }); + + /** + * Acts as multiple `prop`: array of keys in, array of values out. Preserves order. + * + * @func + * @memberOf R + * @category Object + * @sig [k] -> {k: v} -> [v] + * @param {Array} ps The property names to fetch + * @param {Object} obj The object to query + * @return {Array} The corresponding values or partially applied function. + * @example + * + * R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2] + * R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2] + * + * var fullName = R.compose(R.join(' '), R.props(['first', 'last'])); + * fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth' + */ + var props = _curry2(function props(ps, obj) { + var len = ps.length; + var out = []; + var idx = 0; + while (idx < len) { + out[idx] = obj[ps[idx]]; + idx += 1; + } + return out; + }); + + /** + * Returns a list of numbers from `from` (inclusive) to `to` + * (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [Number] + * @param {Number} from The first number in the list. + * @param {Number} to One more than the last number in the list. + * @return {Array} The list of numbers in tthe set `[a, b)`. + * @example + * + * R.range(1, 5); //=> [1, 2, 3, 4] + * R.range(50, 53); //=> [50, 51, 52] + */ + var range = _curry2(function range(from, to) { + if (!(_isNumber(from) && _isNumber(to))) { + throw new TypeError('Both arguments to range must be numbers'); + } + var result = []; + var n = from; + while (n < to) { + result.push(n); + n += 1; + } + return result; + }); + + /** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * Similar to `reduce`, except moves through the input list from the right to the left. + * + * The iterator function receives two values: *(acc, value)* + * + * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var pairs = [ ['a', 1], ['b', 2], ['c', 3] ]; + * var flattenPairs = function(acc, pair) { + * return acc.concat(pair); + * }; + * + * R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ] + */ + var reduceRight = _curry3(function reduceRight(fn, acc, list) { + var idx = list.length - 1; + while (idx >= 0) { + acc = fn(acc, list[idx]); + idx -= 1; + } + return acc; + }); + + /** + * Returns a value wrapped to indicate that it is the final value of the + * reduce and transduce functions. The returned value + * should be considered a black box: the internal structure is not + * guaranteed to be stable. + * + * Note: this optimization is unavailable to functions not explicitly listed + * above. For instance, it is not currently supported by reduceIndexed, + * reduceRight, or reduceRightIndexed. + * + * @func + * @memberOf R + * @category List + * @see R.reduce, R.transduce + * @sig a -> * + * @param {*} x The final value of the reduce. + * @return {*} The wrapped value. + * @example + * + * R.reduce( + * R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)), + * 0, + * [1, 2, 3, 4, 5]) // 10 + */ + var reduced = _curry1(_reduced); + + /** + * Removes the sub-list of `list` starting at index `start` and containing + * `count` elements. _Note that this is not destructive_: it returns a + * copy of the list with the changes. + * No lists have been harmed in the application of this function. + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @param {Number} start The position to start removing elements + * @param {Number} count The number of elements to remove + * @param {Array} list The list to remove from + * @return {Array} A new Array with `count` elements from `start` removed. + * @example + * + * R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8] + */ + var remove = _curry3(function remove(start, count, list) { + return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count))); + }); + + /** + * Replace a substring or regex match in a string with a replacement. + * + * @func + * @memberOf R + * @category String + * @sig RegExp|String -> String -> String -> String + * @param {RegExp|String} pattern A regular expression or a substring to match. + * @param {String} replacement The string to replace the matches with. + * @param {String} str The String to do the search and replacement in. + * @return {String} The result. + * @example + * + * R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo' + * R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo' + * + * // Use the "g" (global) flag to replace all occurrences: + * R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar' + */ + var replace = _curry3(function replace(regex, replacement, str) { + return str.replace(regex, replacement); + }); + + /** + * Returns a new list with the same elements as the original list, just + * in the reverse order. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The list to reverse. + * @return {Array} A copy of the list in reverse order. + * @example + * + * R.reverse([1, 2, 3]); //=> [3, 2, 1] + * R.reverse([1, 2]); //=> [2, 1] + * R.reverse([1]); //=> [1] + * R.reverse([]); //=> [] + */ + var reverse = _curry1(function reverse(list) { + return _slice(list).reverse(); + }); + + /** + * Scan is similar to reduce, but returns a list of successively reduced values from the left + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> [a] + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {Array} A list of all intermediately reduced values. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24] + */ + var scan = _curry3(function scan(fn, acc, list) { + var idx = 0, len = list.length, result = [acc]; + while (idx < len) { + acc = fn(acc, list[idx]); + result[idx + 1] = acc; + idx += 1; + } + return result; + }); + + /** + * Returns the result of "setting" the portion of the given data structure + * focused by the given lens to the given value. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> a -> s -> s + * @param {Lens} lens + * @param {*} v + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lensProp('x'); + * + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2} + */ + var set = _curry3(function set(lens, v, x) { + return over(lens, always(v), x); + }); + + /** + * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a + * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero + * if they are equal. Please note that this is a **copy** of the list. It does not modify the original. + * + * @func + * @memberOf R + * @category List + * @sig (a,a -> Number) -> [a] -> [a] + * @param {Function} comparator A sorting function :: a -> b -> Int + * @param {Array} list The list to sort + * @return {Array} a new array with its elements sorted by the comparator function. + * @example + * + * var diff = function(a, b) { return a - b; }; + * R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7] + */ + var sort = _curry2(function sort(comparator, list) { + return _slice(list).sort(comparator); + }); + + /** + * Sorts the list according to the supplied function. + * + * @func + * @memberOf R + * @category Relation + * @sig Ord b => (a -> b) -> [a] -> [a] + * @param {Function} fn + * @param {Array} list The list to sort. + * @return {Array} A new list sorted by the keys generated by `fn`. + * @example + * + * var sortByFirstItem = R.sortBy(prop(0)); + * var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name'))); + * var pairs = [[-1, 1], [-2, 2], [-3, 3]]; + * sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]] + * var alice = { + * name: 'ALICE', + * age: 101 + * }; + * var bob = { + * name: 'Bob', + * age: -10 + * }; + * var clara = { + * name: 'clara', + * age: 314.159 + * }; + * var people = [clara, bob, alice]; + * sortByNameCaseInsensitive(people); //=> [alice, bob, clara] + */ + var sortBy = _curry2(function sortBy(fn, list) { + return _slice(list).sort(function (a, b) { + var aa = fn(a); + var bb = fn(b); + return aa < bb ? -1 : aa > bb ? 1 : 0; + }); + }); + + /** + * Subtracts two numbers. Equivalent to `a - b` but curried. + * + * @func + * @memberOf R + * @category Math + * @sig Number -> Number -> Number + * @param {Number} a The first value. + * @param {Number} b The second value. + * @return {Number} The result of `a - b`. + * @see R.add + * @example + * + * R.subtract(10, 8); //=> 2 + * + * var minus5 = R.subtract(R.__, 5); + * minus5(17); //=> 12 + * + * var complementaryAngle = R.subtract(90); + * complementaryAngle(30); //=> 60 + * complementaryAngle(72); //=> 18 + */ + var subtract = _curry2(function subtract(a, b) { + return a - b; + }); + + /** + * Returns a new list containing the last `n` elements of a given list, passing each value + * to the supplied predicate function, and terminating when the predicate function returns + * `false`. Excludes the element that caused the predicate function to fail. The predicate + * function is passed one argument: *(value)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.dropLastWhile + * @example + * + * var isNotOne = function(x) { + * return !(x === 1); + * }; + * + * R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4] + */ + var takeLastWhile = _curry2(function takeLastWhile(fn, list) { + var idx = list.length - 1; + while (idx >= 0 && fn(list[idx])) { + idx -= 1; + } + return _slice(list, idx + 1, Infinity); + }); + + /** + * Runs the given function with the supplied object, then returns the object. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> *) -> a -> a + * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away. + * @param {*} x + * @return {*} `x`. + * @example + * + * var sayX = function(x) { console.log('x is ' + x); }; + * R.tap(sayX, 100); //=> 100 + * //-> 'x is 100' + */ + var tap = _curry2(function tap(fn, x) { + fn(x); + return x; + }); + + /** + * Determines whether a given string matches a given regular expression. + * + * @func + * @memberOf R + * @see R.match + * @category String + * @sig RegExp -> String -> Boolean + * @param {RegExp} pattern + * @param {String} str + * @return {Boolean} + * @example + * + * R.test(/^x/, 'xyz'); //=> true + * R.test(/^y/, 'xyz'); //=> false + */ + var test = _curry2(function test(pattern, str) { + return _cloneRegExp(pattern).test(str); + }); + + /** + * Calls an input function `n` times, returning an array containing the results of those + * function calls. + * + * `fn` is passed one argument: The current value of `n`, which begins at `0` and is + * gradually incremented to `n - 1`. + * + * @func + * @memberOf R + * @category List + * @sig (i -> a) -> i -> [a] + * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`. + * @param {Number} n A value between `0` and `n - 1`. Increments after each function call. + * @return {Array} An array containing the return values of all calls to `fn`. + * @example + * + * R.times(R.identity, 5); //=> [0, 1, 2, 3, 4] + */ + var times = _curry2(function times(fn, n) { + var len = Number(n); + var list = new Array(len); + var idx = 0; + while (idx < len) { + list[idx] = fn(idx); + idx += 1; + } + return list; + }); + + /** + * Converts an object into an array of key, value arrays. + * Only the object's own properties are used. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> [[String,*]] + * @param {Object} obj The object to extract from + * @return {Array} An array of key, value arrays from the object's own properties. + * @see R.fromPairs + * @example + * + * R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]] + */ + var toPairs = _curry1(function toPairs(obj) { + var pairs = []; + for (var prop in obj) { + if (_has(prop, obj)) { + pairs[pairs.length] = [ + prop, + obj[prop] + ]; + } + } + return pairs; + }); + + /** + * Converts an object into an array of key, value arrays. + * The object's own properties and prototype properties are used. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> [[String,*]] + * @param {Object} obj The object to extract from + * @return {Array} An array of key, value arrays from the object's own + * and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.toPairsIn(f); //=> [['x','X'], ['y','Y']] + */ + var toPairsIn = _curry1(function toPairsIn(obj) { + var pairs = []; + for (var prop in obj) { + pairs[pairs.length] = [ + prop, + obj[prop] + ]; + } + return pairs; + }); + + /** + * Removes (strips) whitespace from both ends of the string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to trim. + * @return {String} Trimmed version of `str`. + * @example + * + * R.trim(' xyz '); //=> 'xyz' + * R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z'] + */ + var trim = function () { + var ws = '\t\n\x0B\f\r \xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + '\u2029\uFEFF'; + var zeroWidth = '\u200B'; + var hasProtoTrim = typeof String.prototype.trim === 'function'; + if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) { + return _curry1(function trim(str) { + var beginRx = new RegExp('^[' + ws + '][' + ws + ']*'); + var endRx = new RegExp('[' + ws + '][' + ws + ']*$'); + return str.replace(beginRx, '').replace(endRx, ''); + }); + } else { + return _curry1(function trim(str) { + return str.trim(); + }); + } + }(); + + /** + * Gives a single-word string description of the (native) type of a value, returning such + * answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user + * Object types any further, reporting them all as 'Object'. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> String + * @param {*} val The value to test + * @return {String} + * @example + * + * R.type({}); //=> "Object" + * R.type(1); //=> "Number" + * R.type(false); //=> "Boolean" + * R.type('s'); //=> "String" + * R.type(null); //=> "Null" + * R.type([]); //=> "Array" + * R.type(/[A-z]/); //=> "RegExp" + */ + var type = _curry1(function type(val) { + return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1); + }); + + /** + * Takes a function `fn`, which takes a single array argument, and returns + * a function which: + * + * - takes any number of positional arguments; + * - passes these arguments to `fn` as an array; and + * - returns the result. + * + * In other words, R.unapply derives a variadic function from a function + * which takes an array. R.unapply is the inverse of R.apply. + * + * @func + * @memberOf R + * @category Function + * @sig ([*...] -> a) -> (*... -> a) + * @param {Function} fn + * @return {Function} + * @see R.apply + * @example + * + * R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]' + */ + var unapply = _curry1(function unapply(fn) { + return function () { + return fn(_slice(arguments)); + }; + }); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly 1 + * parameter. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> b) -> (a -> b) + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity 1. + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.unary(takesTwoArgs); + * takesOneArg.length; //=> 1 + * // Only 1 argument is passed to the wrapped function + * takesOneArg(1, 2); //=> [1, undefined] + */ + var unary = _curry1(function unary(fn) { + return nAry(1, fn); + }); + + /** + * Returns a function of arity `n` from a (manually) curried function. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (a -> b) -> (a -> c) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to uncurry. + * @return {Function} A new function. + * @see R.curry + * @example + * + * var addFour = function(a) { + * return function(b) { + * return function(c) { + * return function(d) { + * return a + b + c + d; + * }; + * }; + * }; + * }; + * + * var uncurriedAddFour = R.uncurryN(4, addFour); + * curriedAddFour(1, 2, 3, 4); //=> 10 + */ + var uncurryN = _curry2(function uncurryN(depth, fn) { + return curryN(depth, function () { + var currentDepth = 1; + var value = fn; + var idx = 0; + var endIdx; + while (currentDepth <= depth && typeof value === 'function') { + endIdx = currentDepth === depth ? arguments.length : idx + value.length; + value = value.apply(this, _slice(arguments, idx, endIdx)); + currentDepth += 1; + idx = endIdx; + } + return value; + }); + }); + + /** + * Builds a list from a seed value. Accepts an iterator function, which returns either false + * to stop iteration or an array of length 2 containing the value to add to the resulting + * list and the seed to be used in the next call to the iterator function. + * + * The iterator function receives one argument: *(seed)*. + * + * @func + * @memberOf R + * @category List + * @sig (a -> [b]) -> * -> [b] + * @param {Function} fn The iterator function. receives one argument, `seed`, and returns + * either false to quit iteration or an array of length two to proceed. The element + * at index 0 of this array will be added to the resulting array, and the element + * at index 1 will be passed to the next call to `fn`. + * @param {*} seed The seed value. + * @return {Array} The final list. + * @example + * + * var f = function(n) { return n > 50 ? false : [-n, n + 10] }; + * R.unfold(f, 10); //=> [-10, -20, -30, -40, -50] + */ + var unfold = _curry2(function unfold(fn, seed) { + var pair = fn(seed); + var result = []; + while (pair && pair.length) { + result[result.length] = pair[0]; + pair = fn(pair[1]); + } + return result; + }); + + /** + * Returns a new list containing only one copy of each element in the original list, based + * upon the value returned by applying the supplied predicate to two list elements. Prefers + * the first item if two items compare equal based on the predicate. + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * var strEq = function(a, b) { return String(a) === String(b); }; + * R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2] + * R.uniqWith(strEq)([{}, {}]); //=> [{}] + * R.uniqWith(strEq)([1, '1', 1]); //=> [1] + * R.uniqWith(strEq)(['1', 1, 1]); //=> ['1'] + */ + var uniqWith = _curry2(function uniqWith(pred, list) { + var idx = 0, len = list.length; + var result = [], item; + while (idx < len) { + item = list[idx]; + if (!_containsWith(pred, item, result)) { + result[result.length] = item; + } + idx += 1; + } + return result; + }); + + /** + * Returns a new copy of the array with the element at the + * provided index replaced with the given value. + * @see R.adjust + * + * @func + * @memberOf R + * @category List + * @sig Number -> a -> [a] -> [a] + * @param {Number} idx The index to update. + * @param {*} x The value to exist at the given index of the returned array. + * @param {Array|Arguments} list The source array-like object to be updated. + * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`. + * @example + * + * R.update(1, 11, [0, 1, 2]); //=> [0, 11, 2] + * R.update(1)(11)([0, 1, 2]); //=> [0, 11, 2] + */ + var update = _curry3(function update(idx, x, list) { + return adjust(always(x), idx, list); + }); + + /** + * Returns a list of all the enumerable own properties of the supplied object. + * Note that the order of the output array is not guaranteed across + * different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [v] + * @param {Object} obj The object to extract values from + * @return {Array} An array of the values of the object's own properties. + * @example + * + * R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3] + */ + var values = _curry1(function values(obj) { + var props = keys(obj); + var len = props.length; + var vals = []; + var idx = 0; + while (idx < len) { + vals[idx] = obj[props[idx]]; + idx += 1; + } + return vals; + }); + + /** + * Returns a list of all the properties, including prototype properties, + * of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [v] + * @param {Object} obj The object to extract values from + * @return {Array} An array of the values of the object's own and prototype properties. + * @example + * + * var F = function() { this.x = 'X'; }; + * F.prototype.y = 'Y'; + * var f = new F(); + * R.valuesIn(f); //=> ['X', 'Y'] + */ + var valuesIn = _curry1(function valuesIn(obj) { + var prop, vs = []; + for (prop in obj) { + vs[vs.length] = obj[prop]; + } + return vs; + }); + + /** + * Returns a "view" of the given data structure, determined by the given lens. + * The lens's focus determines which portion of the data structure is visible. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Lens s a -> s -> a + * @param {Lens} lens + * @param {*} x + * @return {*} + * @see R.prop, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lensProp('x'); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.view(xLens, {x: 4, y: 2}); //=> 4 + */ + var view = function () { + var Const = function (x) { + return { + value: x, + map: function () { + return this; + } + }; + }; + return _curry2(function view(lens, x) { + return lens(Const)(x).value; + }); + }(); + + /** + * Takes a spec object and a test object; returns true if the test satisfies + * the spec. Each of the spec's own properties must be a predicate function. + * Each predicate is applied to the value of the corresponding property of + * the test object. `where` returns true if all the predicates return true, + * false otherwise. + * + * `where` is well suited to declaratively expressing constraints for other + * functions such as `filter` and `find`. + * + * @func + * @memberOf R + * @category Object + * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean + * @param {Object} spec + * @param {Object} testObj + * @return {Boolean} + * @example + * + * // pred :: Object -> Boolean + * var pred = R.where({ + * a: R.equals('foo'), + * b: R.complement(R.equals('bar')), + * x: R.gt(_, 10), + * y: R.lt(_, 20) + * }); + * + * pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true + * pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false + * pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false + * pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false + * pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false + */ + var where = _curry2(function where(spec, testObj) { + for (var prop in spec) { + if (_has(prop, spec) && !spec[prop](testObj[prop])) { + return false; + } + } + return true; + }); + + /** + * Wrap a function inside another to allow you to make adjustments to the parameters, or do + * other processing either before the internal function is called or with its results. + * + * @func + * @memberOf R + * @category Function + * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c) + * @param {Function} fn The function to wrap. + * @param {Function} wrapper The wrapper function. + * @return {Function} The wrapped function. + * @example + * + * var greet = function(name) {return 'Hello ' + name;}; + * + * var shoutedGreet = R.wrap(greet, function(gr, name) { + * return gr(name).toUpperCase(); + * }); + * shoutedGreet("Kathy"); //=> "HELLO KATHY" + * + * var shortenedGreet = R.wrap(greet, function(gr, name) { + * return gr(name.substring(0, 3)); + * }); + * shortenedGreet("Robert"); //=> "Hello Rob" + */ + var wrap = _curry2(function wrap(fn, wrapper) { + return curryN(fn.length, function () { + return wrapper.apply(this, _concat([fn], arguments)); + }); + }); + + /** + * Creates a new list out of the two supplied by creating each possible + * pair from the lists. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] -> [[a,b]] + * @param {Array} as The first list. + * @param {Array} bs The second list. + * @return {Array} The list made by combining each possible pair from + * `as` and `bs` into pairs (`[a, b]`). + * @example + * + * R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']] + */ + // = xprodWith(prepend); (takes about 3 times as long...) + var xprod = _curry2(function xprod(a, b) { + // = xprodWith(prepend); (takes about 3 times as long...) + var idx = 0; + var ilen = a.length; + var j; + var jlen = b.length; + var result = []; + while (idx < ilen) { + j = 0; + while (j < jlen) { + result[result.length] = [ + a[idx], + b[j] + ]; + j += 1; + } + idx += 1; + } + return result; + }); + + /** + * Creates a new list out of the two supplied by pairing up + * equally-positioned items from both lists. The returned list is + * truncated to the length of the shorter of the two input lists. + * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] -> [[a,b]] + * @param {Array} list1 The first array to consider. + * @param {Array} list2 The second array to consider. + * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`. + * @example + * + * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']] + */ + var zip = _curry2(function zip(a, b) { + var rv = []; + var idx = 0; + var len = Math.min(a.length, b.length); + while (idx < len) { + rv[idx] = [ + a[idx], + b[idx] + ]; + idx += 1; + } + return rv; + }); + + /** + * Creates a new object out of a list of keys and a list of values. + * + * @func + * @memberOf R + * @category List + * @sig [String] -> [*] -> {String: *} + * @param {Array} keys The array that will be properties on the output object. + * @param {Array} values The list of values on the output object. + * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`. + * @example + * + * R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3} + */ + var zipObj = _curry2(function zipObj(keys, values) { + var idx = 0, len = keys.length, out = {}; + while (idx < len) { + out[keys[idx]] = values[idx]; + idx += 1; + } + return out; + }); + + /** + * Creates a new list out of the two supplied by applying the function to + * each equally-positioned pair in the lists. The returned list is + * truncated to the length of the shorter of the two input lists. + * + * @function + * @memberOf R + * @category List + * @sig (a,b -> c) -> [a] -> [b] -> [c] + * @param {Function} fn The function used to combine the two elements into one value. + * @param {Array} list1 The first array to consider. + * @param {Array} list2 The second array to consider. + * @return {Array} The list made by combining same-indexed elements of `list1` and `list2` + * using `fn`. + * @example + * + * var f = function(x, y) { + * // ... + * }; + * R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']); + * //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')] + */ + var zipWith = _curry3(function zipWith(fn, a, b) { + var rv = [], idx = 0, len = Math.min(a.length, b.length); + while (idx < len) { + rv[idx] = fn(a[idx], b[idx]); + idx += 1; + } + return rv; + }); + + /** + * A function that always returns `false`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> false + * @return {Boolean} false + * @see R.always, R.T + * @example + * + * R.F(); //=> false + */ + var F = always(false); + + /** + * A function that always returns `true`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> true + * @return {Boolean} `true`. + * @see R.always, R.F + * @example + * + * R.T(); //=> true + */ + var T = always(true); + + /** + * Similar to hasMethod, this checks whether a function has a [methodname] + * function. If it isn't an array it will execute that function otherwise it will + * default to the ramda implementation. + * + * @private + * @param {Function} fn ramda implemtation + * @param {String} methodname property to check for a custom implementation + * @return {Object} Whatever the return value of the method is. + */ + var _checkForMethod = function _checkForMethod(methodname, fn) { + return function () { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1)); + }; + }; + + /** + * Copies an object. + * + * @private + * @param {*} value The value to be copied + * @param {Array} refFrom Array containing the source references + * @param {Array} refTo Array containing the copied source references + * @return {*} The copied value. + */ + var _clone = function _clone(value, refFrom, refTo) { + var copy = function copy(copiedValue) { + var len = refFrom.length; + var idx = 0; + while (idx < len) { + if (value === refFrom[idx]) { + return refTo[idx]; + } + idx += 1; + } + refFrom[idx + 1] = value; + refTo[idx + 1] = copiedValue; + for (var key in value) { + copiedValue[key] = _clone(value[key], refFrom, refTo); + } + return copiedValue; + }; + switch (type(value)) { + case 'Object': + return copy({}); + case 'Array': + return copy([]); + case 'Date': + return new Date(value); + case 'RegExp': + return _cloneRegExp(value); + default: + return value; + } + }; + + var _createPartialApplicator = function _createPartialApplicator(concat) { + return function (fn) { + var args = _slice(arguments, 1); + return _arity(Math.max(0, fn.length - args.length), function () { + return fn.apply(this, concat(args, arguments)); + }); + }; + }; + + /** + * Returns a function that dispatches with different strategies based on the + * object in list position (last argument). If it is an array, executes [fn]. + * Otherwise, if it has a function with [methodname], it will execute that + * function (functor case). Otherwise, if it is a transformer, uses transducer + * [xf] to return a new transformer (transducer case). Otherwise, it will + * default to executing [fn]. + * + * @private + * @param {String} methodname property to check for a custom implementation + * @param {Function} xf transducer to initialize if object is transformer + * @param {Function} fn default ramda implementation + * @return {Function} A function that dispatches on object in list position + */ + var _dispatchable = function _dispatchable(methodname, xf, fn) { + return function () { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + if (!_isArray(obj)) { + var args = _slice(arguments, 0, length - 1); + if (typeof obj[methodname] === 'function') { + return obj[methodname].apply(obj, args); + } + if (_isTransformer(obj)) { + var transducer = xf.apply(null, args); + return transducer(obj); + } + } + return fn.apply(this, arguments); + }; + }; + + // The algorithm used to handle cyclic structures is + // inspired by underscore's isEqual + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + var _equals = function _equals(a, b, stackA, stackB) { + var typeA = type(a); + if (typeA !== type(b)) { + return false; + } + if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') { + return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b); + } + if (identical(a, b)) { + return true; + } + if (typeA === 'RegExp') { + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode; + } + if (Object(a) === a) { + if (typeA === 'Date' && a.getTime() !== b.getTime()) { + return false; + } + var keysA = keys(a); + if (keysA.length !== keys(b).length) { + return false; + } + var idx = stackA.length - 1; + while (idx >= 0) { + if (stackA[idx] === a) { + return stackB[idx] === b; + } + idx -= 1; + } + stackA[stackA.length] = a; + stackB[stackB.length] = b; + idx = keysA.length - 1; + while (idx >= 0) { + var key = keysA[idx]; + if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) { + return false; + } + idx -= 1; + } + stackA.pop(); + stackB.pop(); + return true; + } + return false; + }; + + /** + * Private function that determines whether or not a provided object has a given method. + * Does not ignore methods stored on the object's prototype chain. Used for dynamically + * dispatching Ramda methods to non-Array objects. + * + * @private + * @param {String} methodName The name of the method to check for. + * @param {Object} obj The object to test. + * @return {Boolean} `true` has a given method, `false` otherwise. + * @example + * + * var person = { name: 'John' }; + * person.shout = function() { alert(this.name); }; + * + * _hasMethod('shout', person); //=> true + * _hasMethod('foo', person); //=> false + */ + var _hasMethod = function _hasMethod(methodName, obj) { + return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function'; + }; + + /** + * `_makeFlat` is a helper function that returns a one-level or fully recursive function + * based on the flag passed in. + * + * @private + */ + var _makeFlat = function _makeFlat(recursive) { + return function flatt(list) { + var value, result = [], idx = 0, j, ilen = list.length, jlen; + while (idx < ilen) { + if (isArrayLike(list[idx])) { + value = recursive ? flatt(list[idx]) : list[idx]; + j = 0; + jlen = value.length; + while (j < jlen) { + result[result.length] = value[j]; + j += 1; + } + } else { + result[result.length] = list[idx]; + } + idx += 1; + } + return result; + }; + }; + + var _reduce = function () { + function _arrayReduce(xf, acc, list) { + var idx = 0, len = list.length; + while (idx < len) { + acc = xf['@@transducer/step'](acc, list[idx]); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + idx += 1; + } + return xf['@@transducer/result'](acc); + } + function _iterableReduce(xf, acc, iter) { + var step = iter.next(); + while (!step.done) { + acc = xf['@@transducer/step'](acc, step.value); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + step = iter.next(); + } + return xf['@@transducer/result'](acc); + } + function _methodReduce(xf, acc, obj) { + return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc)); + } + var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator'; + return function _reduce(fn, acc, list) { + if (typeof fn === 'function') { + fn = _xwrap(fn); + } + if (isArrayLike(list)) { + return _arrayReduce(fn, acc, list); + } + if (typeof list.reduce === 'function') { + return _methodReduce(fn, acc, list); + } + if (list[symIterator] != null) { + return _iterableReduce(fn, acc, list[symIterator]()); + } + if (typeof list.next === 'function') { + return _iterableReduce(fn, acc, list); + } + throw new TypeError('reduce: list must be array or iterable'); + }; + }(); + + var _stepCat = function () { + var _stepCatArray = { + '@@transducer/init': Array, + '@@transducer/step': function (xs, x) { + return _concat(xs, [x]); + }, + '@@transducer/result': _identity + }; + var _stepCatString = { + '@@transducer/init': String, + '@@transducer/step': function (a, b) { + return a + b; + }, + '@@transducer/result': _identity + }; + var _stepCatObject = { + '@@transducer/init': Object, + '@@transducer/step': function (result, input) { + return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input); + }, + '@@transducer/result': _identity + }; + return function _stepCat(obj) { + if (_isTransformer(obj)) { + return obj; + } + if (isArrayLike(obj)) { + return _stepCatArray; + } + if (typeof obj === 'string') { + return _stepCatString; + } + if (typeof obj === 'object') { + return _stepCatObject; + } + throw new Error('Cannot create transformer for ' + obj); + }; + }(); + + var _xall = function () { + function XAll(f, xf) { + this.xf = xf; + this.f = f; + this.all = true; + } + XAll.prototype['@@transducer/init'] = _xfBase.init; + XAll.prototype['@@transducer/result'] = function (result) { + if (this.all) { + result = this.xf['@@transducer/step'](result, true); + } + return this.xf['@@transducer/result'](result); + }; + XAll.prototype['@@transducer/step'] = function (result, input) { + if (!this.f(input)) { + this.all = false; + result = _reduced(this.xf['@@transducer/step'](result, false)); + } + return result; + }; + return _curry2(function _xall(f, xf) { + return new XAll(f, xf); + }); + }(); + + var _xany = function () { + function XAny(f, xf) { + this.xf = xf; + this.f = f; + this.any = false; + } + XAny.prototype['@@transducer/init'] = _xfBase.init; + XAny.prototype['@@transducer/result'] = function (result) { + if (!this.any) { + result = this.xf['@@transducer/step'](result, false); + } + return this.xf['@@transducer/result'](result); + }; + XAny.prototype['@@transducer/step'] = function (result, input) { + if (this.f(input)) { + this.any = true; + result = _reduced(this.xf['@@transducer/step'](result, true)); + } + return result; + }; + return _curry2(function _xany(f, xf) { + return new XAny(f, xf); + }); + }(); + + var _xdrop = function () { + function XDrop(n, xf) { + this.xf = xf; + this.n = n; + } + XDrop.prototype['@@transducer/init'] = _xfBase.init; + XDrop.prototype['@@transducer/result'] = _xfBase.result; + XDrop.prototype['@@transducer/step'] = function (result, input) { + if (this.n > 0) { + this.n -= 1; + return result; + } + return this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdrop(n, xf) { + return new XDrop(n, xf); + }); + }(); + + var _xdropWhile = function () { + function XDropWhile(f, xf) { + this.xf = xf; + this.f = f; + } + XDropWhile.prototype['@@transducer/init'] = _xfBase.init; + XDropWhile.prototype['@@transducer/result'] = _xfBase.result; + XDropWhile.prototype['@@transducer/step'] = function (result, input) { + if (this.f) { + if (this.f(input)) { + return result; + } + this.f = null; + } + return this.xf['@@transducer/step'](result, input); + }; + return _curry2(function _xdropWhile(f, xf) { + return new XDropWhile(f, xf); + }); + }(); + + var _xgroupBy = function () { + function XGroupBy(f, xf) { + this.xf = xf; + this.f = f; + this.inputs = {}; + } + XGroupBy.prototype['@@transducer/init'] = _xfBase.init; + XGroupBy.prototype['@@transducer/result'] = function (result) { + var key; + for (key in this.inputs) { + if (_has(key, this.inputs)) { + result = this.xf['@@transducer/step'](result, this.inputs[key]); + if (result['@@transducer/reduced']) { + result = result['@@transducer/value']; + break; + } + } + } + return this.xf['@@transducer/result'](result); + }; + XGroupBy.prototype['@@transducer/step'] = function (result, input) { + var key = this.f(input); + this.inputs[key] = this.inputs[key] || [ + key, + [] + ]; + this.inputs[key][1] = append(input, this.inputs[key][1]); + return result; + }; + return _curry2(function _xgroupBy(f, xf) { + return new XGroupBy(f, xf); + }); + }(); + + /** + * Creates a new list iteration function from an existing one by adding two new parameters + * to its callback function: the current index, and the entire list. + * + * This would turn, for instance, Ramda's simple `map` function into one that more closely + * resembles `Array.prototype.map`. Note that this will only work for functions in which + * the iteration callback function is the first parameter, and where the list is the last + * parameter. (This latter might be unimportant if the list parameter is not used.) + * + * @func + * @memberOf R + * @category Function + * @category List + * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *) + * @param {Function} fn A list iteration function that does not pass index or list to its callback + * @return {Function} An altered list iteration function that passes (item, index, list) to its callback + * @example + * + * var mapIndexed = R.addIndex(R.map); + * mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']); + * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r'] + */ + var addIndex = _curry1(function addIndex(fn) { + return curryN(fn.length, function () { + var idx = 0; + var origFn = arguments[0]; + var list = arguments[arguments.length - 1]; + var args = _slice(arguments); + args[0] = function () { + var result = origFn.apply(this, _concat(arguments, [ + idx, + list + ])); + idx += 1; + return result; + }; + return fn.apply(this, args); + }); + }); + + /** + * Returns `true` if all elements of the list match the predicate, `false` if there are any + * that don't. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is satisfied by every element, `false` + * otherwise. + * @see R.any, R.none + * @example + * + * var lessThan2 = R.flip(R.lt)(2); + * var lessThan3 = R.flip(R.lt)(3); + * R.all(lessThan2)([1, 2]); //=> false + * R.all(lessThan3)([1, 2]); //=> true + */ + var all = _curry2(_dispatchable('all', _xall, function all(fn, list) { + var idx = 0; + while (idx < list.length) { + if (!fn(list[idx])) { + return false; + } + idx += 1; + } + return true; + })); + + /** + * A function that returns the first argument if it's falsy otherwise the second + * argument. Note that this is NOT short-circuited, meaning that if expressions + * are passed they are both evaluated. + * + * Dispatches to the `and` method of the first argument if applicable. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> * -> * + * @param {*} a any value + * @param {*} b any other value + * @return {*} the first argument if falsy otherwise the second argument. + * @see R.both + * @example + * + * R.and(false, true); //=> false + * R.and(0, []); //=> 0 + * R.and(null, ''); => null + */ + var and = _curry2(function and(a, b) { + return _hasMethod('and', a) ? a.and(b) : a && b; + }); + + /** + * Returns `true` if at least one of elements of the list match the predicate, `false` + * otherwise. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false` + * otherwise. + * @see R.all, R.none + * @example + * + * var lessThan0 = R.flip(R.lt)(0); + * var lessThan2 = R.flip(R.lt)(2); + * R.any(lessThan0)([1, 2]); //=> false + * R.any(lessThan2)([1, 2]); //=> true + */ + var any = _curry2(_dispatchable('any', _xany, function any(fn, list) { + var idx = 0; + while (idx < list.length) { + if (fn(list[idx])) { + return true; + } + idx += 1; + } + return false; + })); + + /** + * Wraps a function of any arity (including nullary) in a function that accepts exactly 2 + * parameters. Any extraneous parameters will not be passed to the supplied function. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> c) -> (a, b -> c) + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of + * arity 2. + * @example + * + * var takesThreeArgs = function(a, b, c) { + * return [a, b, c]; + * }; + * takesThreeArgs.length; //=> 3 + * takesThreeArgs(1, 2, 3); //=> [1, 2, 3] + * + * var takesTwoArgs = R.binary(takesThreeArgs); + * takesTwoArgs.length; //=> 2 + * // Only 2 arguments are passed to the wrapped function + * takesTwoArgs(1, 2, 3); //=> [1, 2, undefined] + */ + var binary = _curry1(function binary(fn) { + return nAry(2, fn); + }); + + /** + * Creates a deep copy of the value which may contain (nested) `Array`s and + * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are + * not copied, but assigned by their reference. + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> {*} + * @param {*} value The object or array to clone + * @return {*} A new object or array. + * @example + * + * var objects = [{}, {}, {}]; + * var objectsClone = R.clone(objects); + * objects[0] === objectsClone[0]; //=> false + */ + var clone = _curry1(function clone(value) { + return _clone(value, [], []); + }); + + /** + * Returns a new list consisting of the elements of the first list followed by the elements + * of the second. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list to merge. + * @param {Array} list2 The second set to merge. + * @return {Array} A new array consisting of the contents of `list1` followed by the + * contents of `list2`. If, instead of an Array for `list1`, you pass an + * object with a `concat` method on it, `concat` will call `list1.concat` + * and pass it the value of `list2`. + * + * @example + * + * R.concat([], []); //=> [] + * R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + * R.concat('ABC', 'DEF'); // 'ABCDEF' + */ + var concat = _curry2(function concat(set1, set2) { + if (_isArray(set2)) { + return _concat(set1, set2); + } else if (_hasMethod('concat', set1)) { + return set1.concat(set2); + } else { + throw new TypeError('can\'t concat ' + typeof set1); + } + }); + + /** + * Returns a curried equivalent of the provided function. The curried + * function has two unusual capabilities. First, its arguments needn't + * be provided one at a time. If `f` is a ternary function and `g` is + * `R.curry(f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig (* -> a) -> (* -> a) + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curryN + * @example + * + * var addFourNumbers = function(a, b, c, d) { + * return a + b + c + d; + * }; + * + * var curriedAddFourNumbers = R.curry(addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ + var curry = _curry1(function curry(fn) { + return curryN(fn.length, fn); + }); + + /** + * Returns a new list containing the last `n` elements of a given list, passing each value + * to the supplied predicate function, skipping elements while the predicate function returns + * `true`. The predicate function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.takeWhile + * @example + * + * var lteTwo = function(x) { + * return x <= 2; + * }; + * + * R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1] + */ + var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) { + var idx = 0, len = list.length; + while (idx < len && pred(list[idx])) { + idx += 1; + } + return _slice(list, idx); + })); + + /** + * Returns `true` if its arguments are equivalent, `false` otherwise. + * Dispatches to an `equals` method if present. Handles cyclical data + * structures. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> b -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * R.equals(1, 1); //=> true + * R.equals(1, '1'); //=> false + * R.equals([1, 2, 3], [1, 2, 3]); //=> true + * + * var a = {}; a.v = a; + * var b = {}; b.v = b; + * R.equals(a, b); //=> true + */ + var equals = _curry2(function equals(a, b) { + return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []); + }); + + /** + * Returns a new list containing only those items that match a given predicate function. + * The predicate function is passed one argument: *(value)*. + * + * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native + * `Array.prototype.filter` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.reject + * @example + * + * var isEven = function(n) { + * return n % 2 === 0; + * }; + * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4] + */ + var filter = _curry2(_dispatchable('filter', _xfilter, _filter)); + + /** + * Returns the first element of the list which matches the predicate, or `undefined` if no + * element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> a | undefined + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Object} The element found, or `undefined`. + * @example + * + * var xs = [{a: 1}, {a: 2}, {a: 3}]; + * R.find(R.propEq('a', 2))(xs); //=> {a: 2} + * R.find(R.propEq('a', 4))(xs); //=> undefined + */ + var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) { + var idx = 0; + var len = list.length; + while (idx < len) { + if (fn(list[idx])) { + return list[idx]; + } + idx += 1; + } + })); + + /** + * Returns the index of the first element of the list which matches the predicate, or `-1` + * if no element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Number + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Number} The index of the element found, or `-1`. + * @example + * + * var xs = [{a: 1}, {a: 2}, {a: 3}]; + * R.findIndex(R.propEq('a', 2))(xs); //=> 1 + * R.findIndex(R.propEq('a', 4))(xs); //=> -1 + */ + var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) { + var idx = 0; + var len = list.length; + while (idx < len) { + if (fn(list[idx])) { + return idx; + } + idx += 1; + } + return -1; + })); + + /** + * Returns the last element of the list which matches the predicate, or `undefined` if no + * element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> a | undefined + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Object} The element found, or `undefined`. + * @example + * + * var xs = [{a: 1, b: 0}, {a:1, b: 1}]; + * R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1} + * R.findLast(R.propEq('a', 4))(xs); //=> undefined + */ + var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) { + var idx = list.length - 1; + while (idx >= 0) { + if (fn(list[idx])) { + return list[idx]; + } + idx -= 1; + } + })); + + /** + * Returns the index of the last element of the list which matches the predicate, or + * `-1` if no element matches. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Number + * @param {Function} fn The predicate function used to determine if the element is the + * desired one. + * @param {Array} list The array to consider. + * @return {Number} The index of the element found, or `-1`. + * @example + * + * var xs = [{a: 1, b: 0}, {a:1, b: 1}]; + * R.findLastIndex(R.propEq('a', 1))(xs); //=> 1 + * R.findLastIndex(R.propEq('a', 4))(xs); //=> -1 + */ + var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) { + var idx = list.length - 1; + while (idx >= 0) { + if (fn(list[idx])) { + return idx; + } + idx -= 1; + } + return -1; + })); + + /** + * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting + * them in a new array, depth-first. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] + * @param {Array} list The array to consider. + * @return {Array} The flattened list. + * @see R.unnest + * @example + * + * R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]); + * //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + */ + var flatten = _curry1(_makeFlat(true)); + + /** + * Returns a new function much like the supplied one, except that the first two arguments' + * order is reversed. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z) + * @param {Function} fn The function to invoke with its first two parameters reversed. + * @return {*} The result of invoking `fn` with its first two parameters' order reversed. + * @example + * + * var mergeThree = function(a, b, c) { + * return ([]).concat(a, b, c); + * }; + * + * mergeThree(1, 2, 3); //=> [1, 2, 3] + * + * R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3] + */ + var flip = _curry1(function flip(fn) { + return curry(function (a, b) { + var args = _slice(arguments); + args[0] = b; + args[1] = a; + return fn.apply(this, args); + }); + }); + + /** + * Iterate over an input `list`, calling a provided function `fn` for each element in the + * list. + * + * `fn` receives one argument: *(value)*. + * + * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.forEach` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description + * + * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original + * array. In some libraries this function is named `each`. + * + * @func + * @memberOf R + * @category List + * @sig (a -> *) -> [a] -> [a] + * @param {Function} fn The function to invoke. Receives one argument, `value`. + * @param {Array} list The list to iterate over. + * @return {Array} The original list. + * @example + * + * var printXPlusFive = function(x) { console.log(x + 5); }; + * R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3] + * //-> 6 + * //-> 7 + * //-> 8 + */ + var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) { + var len = list.length; + var idx = 0; + while (idx < len) { + fn(list[idx]); + idx += 1; + } + return list; + })); + + /** + * Returns a list of function names of object's own functions + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> [String] + * @param {Object} obj The objects with functions in it + * @return {Array} A list of the object's own properties that map to functions. + * @example + * + * R.functions(R); // returns list of ramda's own function names + * + * var F = function() { this.x = function(){}; this.y = 1; } + * F.prototype.z = function() {}; + * F.prototype.a = 100; + * R.functions(new F()); //=> ["x"] + */ + var functions = _curry1(_functionsWith(keys)); + + /** + * Returns a list of function names of object's own and prototype functions + * + * @func + * @memberOf R + * @category Object + * @sig {*} -> [String] + * @param {Object} obj The objects with functions in it + * @return {Array} A list of the object's own properties and prototype + * properties that map to functions. + * @example + * + * R.functionsIn(R); // returns list of ramda's own and prototype function names + * + * var F = function() { this.x = function(){}; this.y = 1; } + * F.prototype.z = function() {}; + * F.prototype.a = 100; + * R.functionsIn(new F()); //=> ["x", "z"] + */ + var functionsIn = _curry1(_functionsWith(keysIn)); + + /** + * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function + * on each element, and grouping the results according to values returned. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> String) -> [a] -> {String: [a]} + * @param {Function} fn Function :: a -> String + * @param {Array} list The array to group + * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements + * that produced that key when passed to `fn`. + * @example + * + * var byGrade = R.groupBy(function(student) { + * var score = student.score; + * return score < 65 ? 'F' : + * score < 70 ? 'D' : + * score < 80 ? 'C' : + * score < 90 ? 'B' : 'A'; + * }); + * var students = [{name: 'Abby', score: 84}, + * {name: 'Eddy', score: 58}, + * // ... + * {name: 'Jack', score: 69}]; + * byGrade(students); + * // { + * // 'A': [{name: 'Dianne', score: 99}], + * // 'B': [{name: 'Abby', score: 84}] + * // // ..., + * // 'F': [{name: 'Eddy', score: 58}] + * // } + */ + var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) { + return _reduce(function (acc, elt) { + var key = fn(elt); + acc[key] = append(elt, acc[key] || (acc[key] = [])); + return acc; + }, {}, list); + })); + + /** + * Returns the first element of the given list or string. In some libraries + * this function is named `first`. + * + * @func + * @memberOf R + * @category List + * @see R.tail, R.init, R.last + * @sig [a] -> a | Undefined + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.head(['fi', 'fo', 'fum']); //=> 'fi' + * R.head([]); //=> undefined + * + * R.head('abc'); //=> 'a' + * R.head(''); //=> '' + */ + var head = nth(0); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of those + * elements common to both lists. Duplication is determined according + * to the value returned by applying the supplied predicate to two list + * elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate function that determines whether + * the two supplied elements are equal. + * @param {Array} list1 One list of items to compare + * @param {Array} list2 A second list of items to compare + * @see R.intersection + * @return {Array} A new list containing those elements common to both lists. + * @example + * + * var buffaloSpringfield = [ + * {id: 824, name: 'Richie Furay'}, + * {id: 956, name: 'Dewey Martin'}, + * {id: 313, name: 'Bruce Palmer'}, + * {id: 456, name: 'Stephen Stills'}, + * {id: 177, name: 'Neil Young'} + * ]; + * var csny = [ + * {id: 204, name: 'David Crosby'}, + * {id: 456, name: 'Stephen Stills'}, + * {id: 539, name: 'Graham Nash'}, + * {id: 177, name: 'Neil Young'} + * ]; + * + * var sameId = function(o1, o2) {return o1.id === o2.id;}; + * + * R.intersectionWith(sameId, buffaloSpringfield, csny); + * //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}] + */ + var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) { + var results = [], idx = 0; + while (idx < list1.length) { + if (_containsWith(pred, list1[idx], list2)) { + results[results.length] = list1[idx]; + } + idx += 1; + } + return uniqWith(pred, results); + }); + + /** + * Creates a new list with the separator interposed between elements. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} separator The element to add to the list. + * @param {Array} list The list to be interposed. + * @return {Array} The new list. + * @example + * + * R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a'] + */ + var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) { + var out = []; + var idx = 0; + var length = list.length; + while (idx < length) { + if (idx === length - 1) { + out.push(list[idx]); + } else { + out.push(list[idx], separator); + } + idx += 1; + } + return out; + })); + + /** + * Transforms the items of the list with the transducer and appends the transformed items to + * the accumulator using an appropriate iterator function based on the accumulator type. + * + * The accumulator can be an array, string, object or a transformer. Iterated items will + * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item + * arrays will be merged as key, value pairs. + * + * The accumulator can also be a transformer object that provides a 2-arity reducing iterator + * function, step, 0-arity initial value function, init, and 1-arity result extraction function + * result. The step function is used as the iterator function in reduce. The result function is + * used to convert the final accumulator into the return type and in most cases is R.identity. + * The init function is used to provide the initial accumulator. + * + * The iteration is performed with R.reduce after initializing the transducer. + * + * @func + * @memberOf R + * @category List + * @sig a -> (b -> b) -> [c] -> a + * @param {*} acc The initial accumulator value. + * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var transducer = R.compose(R.map(R.add(1)), R.take(2)); + * + * R.into([], transducer, numbers); //=> [2, 3] + * + * var intoArray = R.into([]); + * intoArray(transducer, numbers); //=> [2, 3] + */ + var into = _curry3(function into(acc, xf, list) { + return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list); + }); + + /** + * Same as R.invertObj, however this accounts for objects + * with duplicate values by putting the values into an + * array. + * + * @func + * @memberOf R + * @category Object + * @sig {s: x} -> {x: [ s, ... ]} + * @param {Object} obj The object or array to invert + * @return {Object} out A new object with keys + * in an array. + * @example + * + * var raceResultsByFirstName = { + * first: 'alice', + * second: 'jake', + * third: 'alice', + * }; + * R.invert(raceResultsByFirstName); + * //=> { 'alice': ['first', 'third'], 'jake':['second'] } + */ + var invert = _curry1(function invert(obj) { + var props = keys(obj); + var len = props.length; + var idx = 0; + var out = {}; + while (idx < len) { + var key = props[idx]; + var val = obj[key]; + var list = _has(val, out) ? out[val] : out[val] = []; + list[list.length] = key; + idx += 1; + } + return out; + }); + + /** + * Returns a new object with the keys of the given object + * as values, and the values of the given object as keys. + * + * @func + * @memberOf R + * @category Object + * @sig {s: x} -> {x: s} + * @param {Object} obj The object or array to invert + * @return {Object} out A new object + * @example + * + * var raceResults = { + * first: 'alice', + * second: 'jake' + * }; + * R.invertObj(raceResults); + * //=> { 'alice': 'first', 'jake':'second' } + * + * // Alternatively: + * var raceResults = ['alice', 'jake']; + * R.invertObj(raceResults); + * //=> { 'alice': '0', 'jake':'1' } + */ + var invertObj = _curry1(function invertObj(obj) { + var props = keys(obj); + var len = props.length; + var idx = 0; + var out = {}; + while (idx < len) { + var key = props[idx]; + out[obj[key]] = key; + idx += 1; + } + return out; + }); + + /** + * Returns the last element of the given list or string. + * + * @func + * @memberOf R + * @category List + * @see R.init, R.head, R.tail + * @sig [a] -> a | Undefined + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.last(['fi', 'fo', 'fum']); //=> 'fum' + * R.last([]); //=> undefined + * + * R.last('abc'); //=> 'c' + * R.last(''); //=> '' + */ + var last = nth(-1); + + /** + * Returns the position of the last occurrence of an item in + * an array, or -1 if the item is not included in the array. + * `R.equals` is used to determine equality. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Number + * @param {*} target The item to find. + * @param {Array} xs The array to search in. + * @return {Number} the index of the target, or -1 if the target is not found. + * @see R.indexOf + * @example + * + * R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6 + * R.lastIndexOf(10, [1,2,3,4]); //=> -1 + */ + var lastIndexOf = _curry2(function lastIndexOf(target, xs) { + if (_hasMethod('lastIndexOf', xs)) { + return xs.lastIndexOf(target); + } else { + var idx = xs.length - 1; + while (idx >= 0) { + if (equals(xs[idx], target)) { + return idx; + } + idx -= 1; + } + return -1; + } + }); + + /** + * Returns a new list, constructed by applying the supplied function to every element of the + * supplied list. + * + * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the + * native `Array.prototype.map` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [b] + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {Array} list The list to be iterated over. + * @return {Array} The new list. + * @example + * + * var double = function(x) { + * return x * 2; + * }; + * + * R.map(double, [1, 2, 3]); //=> [2, 4, 6] + */ + var map = _curry2(_dispatchable('map', _xmap, _map)); + + /** + * Map, but for objects. Creates an object with the same keys as `obj` and values + * generated by running each property of `obj` through `fn`. `fn` is passed one argument: + * *(value)*. + * + * @func + * @memberOf R + * @category Object + * @sig (v -> v) -> {k: v} -> {k: v} + * @param {Function} fn A function called for each property in `obj`. Its return value will + * become a new property on the return object. + * @param {Object} obj The object to iterate over. + * @return {Object} A new object with the same keys as `obj` and values that are the result + * of running each property through `fn`. + * @example + * + * var values = { x: 1, y: 2, z: 3 }; + * var double = function(num) { + * return num * 2; + * }; + * + * R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 } + */ + var mapObj = _curry2(function mapObj(fn, obj) { + return _reduce(function (acc, key) { + acc[key] = fn(obj[key]); + return acc; + }, {}, keys(obj)); + }); + + /** + * Like `mapObj`, but but passes additional arguments to the predicate function. The + * predicate function is passed three arguments: *(value, key, obj)*. + * + * @func + * @memberOf R + * @category Object + * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v} + * @param {Function} fn A function called for each property in `obj`. Its return value will + * become a new property on the return object. + * @param {Object} obj The object to iterate over. + * @return {Object} A new object with the same keys as `obj` and values that are the result + * of running each property through `fn`. + * @example + * + * var values = { x: 1, y: 2, z: 3 }; + * var prependKeyAndDouble = function(num, key, obj) { + * return key + (num * 2); + * }; + * + * R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' } + */ + var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) { + return _reduce(function (acc, key) { + acc[key] = fn(obj[key], key, obj); + return acc; + }, {}, keys(obj)); + }); + + /** + * Returns `true` if no elements of the list match the predicate, + * `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> Boolean + * @param {Function} fn The predicate function. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise. + * @see R.all, R.any + * @example + * + * R.none(R.isNaN, [1, 2, 3]); //=> true + * R.none(R.isNaN, [1, 2, 3, NaN]); //=> false + */ + var none = _curry2(_complement(_dispatchable('any', _xany, any))); + + /** + * A function that returns the first truthy of two arguments otherwise the + * last argument. Note that this is NOT short-circuited, meaning that if + * expressions are passed they are both evaluated. + * + * Dispatches to the `or` method of the first argument if applicable. + * + * @func + * @memberOf R + * @category Logic + * @sig * -> * -> * + * @param {*} a any value + * @param {*} b any other value + * @return {*} the first truthy argument, otherwise the last argument. + * @see R.either + * @example + * + * R.or(false, true); //=> true + * R.or(0, []); //=> [] + * R.or(null, ''); => '' + */ + var or = _curry2(function or(a, b) { + return _hasMethod('or', a) ? a.or(b) : a || b; + }); + + /** + * Accepts as its arguments a function and any number of values and returns a function that, + * when invoked, calls the original function with all of the values prepended to the + * original function's arguments list. In some libraries this function is named `applyLeft`. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n) + * @param {Function} fn The function to invoke. + * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked. + * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` + * with `args` prepended to `fn`'s arguments list. + * @example + * + * var multiply = function(a, b) { return a * b; }; + * var double = R.partial(multiply, 2); + * double(2); //=> 4 + * + * var greet = function(salutation, title, firstName, lastName) { + * return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; + * }; + * var sayHello = R.partial(greet, 'Hello'); + * var sayHelloToMs = R.partial(sayHello, 'Ms.'); + * sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!' + */ + var partial = curry(_createPartialApplicator(_concat)); + + /** + * Accepts as its arguments a function and any number of values and returns a function that, + * when invoked, calls the original function with all of the values appended to the original + * function's arguments list. + * + * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments + * from the right to the left. In some libraries this function is named `applyRight`. + * + * @func + * @memberOf R + * @category Function + * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i) + * @param {Function} fn The function to invoke. + * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked. + * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with + * `args` appended to `fn`'s arguments list. + * @example + * + * var greet = function(salutation, title, firstName, lastName) { + * return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; + * }; + * var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones'); + * + * greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!' + */ + var partialRight = curry(_createPartialApplicator(flip(_concat))); + + /** + * Takes a predicate and a list and returns the pair of lists of + * elements which do and do not satisfy the predicate, respectively. + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [[a],[a]] + * @param {Function} pred A predicate to determine which array the element belongs to. + * @param {Array} list The array to partition. + * @return {Array} A nested array, containing first an array of elements that satisfied the predicate, + * and second an array of elements that did not satisfy. + * @example + * + * R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']); + * //=> [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ] + */ + var partition = _curry2(function partition(pred, list) { + return _reduce(function (acc, elt) { + var xs = acc[pred(elt) ? 0 : 1]; + xs[xs.length] = elt; + return acc; + }, [ + [], + [] + ], list); + }); + + /** + * Determines whether a nested path on an object has a specific value, + * in `R.equals` terms. Most likely used to filter a list. + * + * @func + * @memberOf R + * @category Relation + * @sig [String] -> * -> {String: *} -> Boolean + * @param {Array} path The path of the nested property to use + * @param {*} val The value to compare the nested property with + * @param {Object} obj The object to check the nested property in + * @return {Boolean} `true` if the value equals the nested object property, + * `false` otherwise. + * @example + * + * var user1 = { address: { zipCode: 90210 } }; + * var user2 = { address: { zipCode: 55555 } }; + * var user3 = { name: 'Bob' }; + * var users = [ user1, user2, user3 ]; + * var isFamous = R.pathEq(['address', 'zipCode'], 90210); + * R.filter(isFamous, users); //=> [ user1 ] + */ + var pathEq = _curry3(function pathEq(_path, val, obj) { + return equals(path(_path, obj), val); + }); + + /** + * Returns a new list by plucking the same named property off all objects in the list supplied. + * + * @func + * @memberOf R + * @category List + * @sig k -> [{k: v}] -> [v] + * @param {Number|String} key The key name to pluck off of each object. + * @param {Array} list The array to consider. + * @return {Array} The list of values for the given key. + * @example + * + * R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2] + * R.pluck(0)([[1, 2], [3, 4]]); //=> [1, 3] + */ + var pluck = _curry2(function pluck(p, list) { + return map(prop(p), list); + }); + + /** + * Returns `true` if the specified object property is equal, in `R.equals` + * terms, to the given value; `false` otherwise. + * + * @func + * @memberOf R + * @category Relation + * @sig String -> a -> Object -> Boolean + * @param {String} name + * @param {*} val + * @param {*} obj + * @return {Boolean} + * @see R.equals, R.propSatisfies + * @example + * + * var abby = {name: 'Abby', age: 7, hair: 'blond'}; + * var fred = {name: 'Fred', age: 12, hair: 'brown'}; + * var rusty = {name: 'Rusty', age: 10, hair: 'brown'}; + * var alois = {name: 'Alois', age: 15, disposition: 'surly'}; + * var kids = [abby, fred, rusty, alois]; + * var hasBrownHair = R.propEq('hair', 'brown'); + * R.filter(hasBrownHair, kids); //=> [fred, rusty] + */ + var propEq = _curry3(function propEq(name, val, obj) { + return propSatisfies(equals(val), name, obj); + }); + + /** + * Returns `true` if the specified object property is of the given type; + * `false` otherwise. + * + * @func + * @memberOf R + * @category Type + * @sig Type -> String -> Object -> Boolean + * @param {Function} type + * @param {String} name + * @param {*} obj + * @return {Boolean} + * @see R.is + * @see R.propSatisfies + * @example + * + * R.propIs(Number, 'x', {x: 1, y: 2}); //=> true + * R.propIs(Number, 'x', {x: 'foo'}); //=> false + * R.propIs(Number, 'x', {}); //=> false + */ + var propIs = _curry3(function propIs(type, name, obj) { + return propSatisfies(is(type), name, obj); + }); + + /** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It may use `R.reduced` to + * shortcut the iteration. + * + * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description + * @see R.reduced + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3]; + * var add = function(a, b) { + * return a + b; + * }; + * + * R.reduce(add, 10, numbers); //=> 16 + */ + var reduce = _curry3(_reduce); + + /** + * Similar to `filter`, except that it keeps only values for which the given predicate + * function returns falsy. The predicate function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.filter + * @example + * + * var isOdd = function(n) { + * return n % 2 === 1; + * }; + * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4] + */ + var reject = _curry2(function reject(fn, list) { + return filter(_complement(fn), list); + }); + + /** + * Returns a fixed list of size `n` containing a specified identical value. + * + * @func + * @memberOf R + * @category List + * @sig a -> n -> [a] + * @param {*} value The value to repeat. + * @param {Number} n The desired size of the output list. + * @return {Array} A new array containing `n` `value`s. + * @example + * + * R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi'] + * + * var obj = {}; + * var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}] + * repeatedObjs[0] === repeatedObjs[1]; //=> true + */ + var repeat = _curry2(function repeat(value, n) { + return times(always(value), n); + }); + + /** + * Returns the elements of the given list or string (or object with a `slice` + * method) from `fromIndex` (inclusive) to `toIndex` (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @sig Number -> Number -> String -> String + * @param {Number} fromIndex The start index (inclusive). + * @param {Number} toIndex The end index (exclusive). + * @param {*} list + * @return {*} + * @example + * + * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] + * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] + * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(0, 3, 'ramda'); //=> 'ram' + */ + var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) { + return Array.prototype.slice.call(list, fromIndex, toIndex); + })); + + /** + * Splits a collection into slices of the specified length. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [[a]] + * @sig Number -> String -> [String] + * @param {Number} n + * @param {Array} list + * @return {Array} + * @example + * + * R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]] + * R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz'] + */ + var splitEvery = _curry2(function splitEvery(n, list) { + if (n <= 0) { + throw new Error('First argument to splitEvery must be a positive integer'); + } + var result = []; + var idx = 0; + while (idx < list.length) { + result.push(slice(idx, idx += n, list)); + } + return result; + }); + + /** + * Adds together all the elements of a list. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list An array of numbers + * @return {Number} The sum of all the numbers in the list. + * @see R.reduce + * @example + * + * R.sum([2,4,6,8,100,1]); //=> 121 + */ + var sum = reduce(add, 0); + + /** + * Returns all but the first element of the given list or string (or object + * with a `tail` method). + * + * @func + * @memberOf R + * @category List + * @see R.head, R.init, R.last + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.tail([1, 2, 3]); //=> [2, 3] + * R.tail([1, 2]); //=> [2] + * R.tail([1]); //=> [] + * R.tail([]); //=> [] + * + * R.tail('abc'); //=> 'bc' + * R.tail('ab'); //=> 'b' + * R.tail('a'); //=> '' + * R.tail(''); //=> '' + */ + var tail = _checkForMethod('tail', slice(1, Infinity)); + + /** + * Returns the first `n` elements of the given list, string, or + * transducer/transformer (or object with a `take` method). + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n + * @param {*} list + * @return {*} + * @see R.drop + * @example + * + * R.take(1, ['foo', 'bar', 'baz']); //=> ['foo'] + * R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] + * R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.take(3, 'ramda'); //=> 'ram' + * + * var personnel = [ + * 'Dave Brubeck', + * 'Paul Desmond', + * 'Eugene Wright', + * 'Joe Morello', + * 'Gerry Mulligan', + * 'Bob Bates', + * 'Joe Dodge', + * 'Ron Crotty' + * ]; + * + * var takeFive = R.take(5); + * takeFive(personnel); + * //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan'] + */ + var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) { + return slice(0, n < 0 ? Infinity : n, xs); + })); + + /** + * Returns a new list containing the first `n` elements of a given list, passing each value + * to the supplied predicate function, and terminating when the predicate function returns + * `false`. Excludes the element that caused the predicate function to fail. The predicate + * function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} A new array. + * @see R.dropWhile + * @example + * + * var isNotFour = function(x) { + * return !(x === 4); + * }; + * + * R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3] + */ + var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) { + var idx = 0, len = list.length; + while (idx < len && fn(list[idx])) { + idx += 1; + } + return _slice(list, 0, idx); + })); + + /** + * Initializes a transducer using supplied iterator function. Returns a single item by + * iterating through the list, successively calling the transformed iterator function and + * passing it an accumulator value and the current value from the array, and then passing + * the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It will be wrapped as a + * transformer to initialize the transducer. A transformer can be passed directly in place + * of an iterator function. In both cases, iteration may be stopped early with the + * `R.reduced` function. + * + * A transducer is a function that accepts a transformer and returns a transformer and can + * be composed directly. + * + * A transformer is an an object that provides a 2-arity reducing iterator function, step, + * 0-arity initial value function, init, and 1-arity result extraction function, result. + * The step function is used as the iterator function in reduce. The result function is used + * to convert the final accumulator into the return type and in most cases is R.identity. + * The init function can be used to provide an initial accumulator, but is ignored by transduce. + * + * The iteration is performed with R.reduce after initializing the transducer. + * + * @func + * @memberOf R + * @category List + * @see R.reduce, R.reduced, R.into + * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a + * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. Wrapped as transformer, if necessary, and used to + * initialize the transducer + * @param {*} acc The initial accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3, 4]; + * var transducer = R.compose(R.map(R.add(1)), R.take(2)); + * + * R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3] + */ + var transduce = curryN(4, function transduce(xf, fn, acc, list) { + return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list); + }); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list. Duplication is + * determined according to the value returned by applying the supplied predicate to two list elements. + * + * @func + * @memberOf R + * @category Relation + * @sig (a,a -> Boolean) -> [a] -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @return {Array} The first and second lists concatenated, with + * duplicates removed. + * @see R.union + * @example + * + * function cmp(x, y) { return x.a === y.a; } + * var l1 = [{a: 1}, {a: 2}]; + * var l2 = [{a: 1}, {a: 4}]; + * R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}] + */ + var unionWith = _curry3(function unionWith(pred, list1, list2) { + return uniqWith(pred, _concat(list1, list2)); + }); + + /** + * Returns a new list containing only one copy of each element in the original list. + * `R.equals` is used to determine equality. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * R.uniq([1, 1, 2, 1]); //=> [1, 2] + * R.uniq([1, '1']); //=> [1, '1'] + * R.uniq([[42], [42]]); //=> [[42]] + */ + var uniq = uniqWith(equals); + + /** + * Returns a new list by pulling every item at the first level of nesting out, and putting + * them in a new array. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [b] + * @param {Array} list The array to consider. + * @return {Array} The flattened list. + * @see R.flatten + * @example + * + * R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]] + * R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6] + */ + var unnest = _curry1(_makeFlat(false)); + + /** + * Accepts a function `fn` and any number of transformer functions and returns a new + * function. When the new function is invoked, it calls the function `fn` with parameters + * consisting of the result of calling each supplied handler on successive arguments to the + * new function. + * + * If more arguments are passed to the returned function than transformer functions, those + * arguments are passed directly to `fn` as additional parameters. If you expect additional + * arguments that don't need to be transformed, although you can ignore them, it's best to + * pass an identity function so that the new function reports the correct arity. + * + * @func + * @memberOf R + * @category Function + * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z) + * @param {Function} fn The function to wrap. + * @param {...Function} transformers A variable number of transformer functions + * @return {Function} The wrapped function. + * @example + * + * var double = function(y) { return y * 2; }; + * var square = function(x) { return x * x; }; + * var add = function(a, b) { return a + b; }; + * // Adds any number of arguments together + * var addAll = function() { + * return R.reduce(add, 0, arguments); + * }; + * + * // Basic example + * var addDoubleAndSquare = R.useWith(addAll, double, square); + * + * //≅ addAll(double(10), square(5)); + * addDoubleAndSquare(10, 5); //=> 45 + * + * // Example of passing more arguments than transformers + * //≅ addAll(double(10), square(5), 100); + * addDoubleAndSquare(10, 5, 100); //=> 145 + * + * // If there are extra _expected_ arguments that don't need to be transformed, although + * // you can ignore them, it might be best to pass in the identity function so that the new + * // function correctly reports arity. + * var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity); + * // addDoubleAndSquareWithExtraParams.length //=> 3 + * //≅ addAll(double(10), square(5), R.identity(100)); + * addDoubleAndSquare(10, 5, 100); //=> 145 + */ + /*, transformers */ + var useWith = curry(function useWith(fn) { + var transformers = _slice(arguments, 1); + var tlen = transformers.length; + return curry(_arity(tlen, function () { + var args = [], idx = 0; + while (idx < tlen) { + args[idx] = transformers[idx](arguments[idx]); + idx += 1; + } + return fn.apply(this, args.concat(_slice(arguments, tlen))); + })); + }); + + /** + * Takes a spec object and a test object; returns true if the test satisfies + * the spec, false otherwise. An object satisfies the spec if, for each of the + * spec's own properties, accessing that property of the object gives the same + * value (in `R.equals` terms) as accessing that property of the spec. + * + * `whereEq` is a specialization of [`where`](#where). + * + * @func + * @memberOf R + * @category Object + * @sig {String: *} -> {String: *} -> Boolean + * @param {Object} spec + * @param {Object} testObj + * @return {Boolean} + * @see R.where + * @example + * + * // pred :: Object -> Boolean + * var pred = R.whereEq({a: 1, b: 2}); + * + * pred({a: 1}); //=> false + * pred({a: 1, b: 2}); //=> true + * pred({a: 1, b: 2, c: 3}); //=> true + * pred({a: 1, b: 1}); //=> false + */ + var whereEq = _curry2(function whereEq(spec, testObj) { + return where(mapObj(equals, spec), testObj); + }); + + var _flatCat = function () { + var preservingReduced = function (xf) { + return { + '@@transducer/init': _xfBase.init, + '@@transducer/result': function (result) { + return xf['@@transducer/result'](result); + }, + '@@transducer/step': function (result, input) { + var ret = xf['@@transducer/step'](result, input); + return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret; + } + }; + }; + return function _xcat(xf) { + var rxf = preservingReduced(xf); + return { + '@@transducer/init': _xfBase.init, + '@@transducer/result': function (result) { + return rxf['@@transducer/result'](result); + }, + '@@transducer/step': function (result, input) { + return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input); + } + }; + }; + }(); + + var _indexOf = function _indexOf(list, item, from) { + var idx = from; + while (idx < list.length) { + if (equals(list[idx], item)) { + return idx; + } + idx += 1; + } + return -1; + }; + + /** + * Create a predicate wrapper which will call a pick function (all/any) for each predicate + * + * @private + * @see R.all + * @see R.any + */ + // Call function immediately if given arguments + // Return a function which will call the predicates with the provided arguments + var _predicateWrap = function _predicateWrap(predPicker) { + return function (preds) { + var predIterator = function () { + var args = arguments; + return predPicker(function (predicate) { + return predicate.apply(null, args); + }, preds); + }; + return arguments.length > 1 ? // Call function immediately if given arguments + predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments + _arity(Math.max.apply(Math, pluck('length', preds)), predIterator); + }; + }; + + var _xchain = _curry2(function _xchain(f, xf) { + return map(f, _flatCat(xf)); + }); + + /** + * Given a list of predicates, returns a new predicate that will be true exactly when all of them are. + * + * @func + * @memberOf R + * @category Logic + * @sig [(*... -> Boolean)] -> (*... -> Boolean) + * @param {Array} list An array of predicate functions + * @param {*} optional Any arguments to pass into the predicates + * @return {Function} a function that applies its arguments to each of + * the predicates, returning `true` if all are satisfied. + * @see R.anyPass + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0}; + * var f = R.allPass([gt10, even]); + * f(11); //=> false + * f(12); //=> true + */ + var allPass = _curry1(_predicateWrap(all)); + + /** + * Given a list of predicates returns a new predicate that will be true exactly when any one of them is. + * + * @func + * @memberOf R + * @category Logic + * @sig [(*... -> Boolean)] -> (*... -> Boolean) + * @param {Array} list An array of predicate functions + * @param {*} optional Any arguments to pass into the predicates + * @return {Function} A function that applies its arguments to each of the predicates, returning + * `true` if all are satisfied. + * @see R.allPass + * @example + * + * var gt10 = function(x) { return x > 10; }; + * var even = function(x) { return x % 2 === 0}; + * var f = R.anyPass([gt10, even]); + * f(11); //=> true + * f(8); //=> true + * f(9); //=> false + */ + var anyPass = _curry1(_predicateWrap(any)); + + /** + * ap applies a list of functions to a list of values. + * + * @func + * @memberOf R + * @category Function + * @sig [f] -> [a] -> [f a] + * @param {Array} fns An array of functions + * @param {Array} vs An array of values + * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn. + * @example + * + * R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6] + */ + var ap = _curry2(function ap(fns, vs) { + return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) { + return _concat(acc, map(fn, vs)); + }, [], fns); + }); + + /** + * Returns the result of calling its first argument with the remaining + * arguments. This is occasionally useful as a converging function for + * `R.converge`: the left branch can produce a function while the right + * branch produces a value to be passed to that function as an argument. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a),*... -> a + * @param {Function} fn The function to apply to the remaining arguments. + * @param {...*} args Any number of positional arguments. + * @return {*} + * @see R.apply + * @example + * + * var indentN = R.pipe(R.times(R.always(' ')), + * R.join(''), + * R.replace(/^(?!$)/gm)); + * + * var format = R.converge(R.call, + * R.pipe(R.prop('indent'), indentN), + * R.prop('value')); + * + * format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n' + */ + var call = curry(function call(fn) { + return fn.apply(this, _slice(arguments, 1)); + }); + + /** + * `chain` maps a function over a list and concatenates the results. + * This implementation is compatible with the + * Fantasy-land Chain spec, and will work with types that implement that spec. + * `chain` is also known as `flatMap` in some libraries + * + * @func + * @memberOf R + * @category List + * @sig (a -> [b]) -> [a] -> [b] + * @param {Function} fn + * @param {Array} list + * @return {Array} + * @example + * + * var duplicate = function(n) { + * return [n, n]; + * }; + * R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3] + */ + var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) { + return unnest(map(fn, list)); + })); + + /** + * Turns a list of Functors into a Functor of a list, applying + * a mapping function to the elements of the list along the way. + * + * @func + * @memberOf R + * @category List + * @see R.commute + * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b] + * @param {Function} fn The transformation function + * @param {Function} of A function that returns the data type to return + * @param {Array} list An array of functors of the same type + * @return {*} + * @example + * + * R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]); //=> [[11, 12], [11, 13]] + * R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]); //=> [[11, 13], [12, 13]] + * R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]] + * R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([11, 12, 13]) + * R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() + */ + var commuteMap = _curry3(function commuteMap(fn, of, list) { + function consF(acc, ftor) { + return ap(map(append, fn(ftor)), acc); + } + return _reduce(consF, of([]), list); + }); + + /** + * Wraps a constructor function inside a curried function that can be called with the same + * arguments and returns the same type. The arity of the function returned is specified + * to allow using variadic constructor functions. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> {*}) -> (* -> {*}) + * @param {Number} n The arity of the constructor function. + * @param {Function} Fn The constructor function to wrap. + * @return {Function} A wrapped, curried constructor function. + * @example + * + * // Variadic constructor function + * var Widget = function() { + * this.children = Array.prototype.slice.call(arguments); + * // ... + * }; + * Widget.prototype = { + * // ... + * }; + * var allConfigs = [ + * // ... + * ]; + * R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets + */ + var constructN = _curry2(function constructN(n, Fn) { + if (n > 10) { + throw new Error('Constructor with greater than ten arguments'); + } + if (n === 0) { + return function () { + return new Fn(); + }; + } + return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) { + switch (arguments.length) { + case 1: + return new Fn($0); + case 2: + return new Fn($0, $1); + case 3: + return new Fn($0, $1, $2); + case 4: + return new Fn($0, $1, $2, $3); + case 5: + return new Fn($0, $1, $2, $3, $4); + case 6: + return new Fn($0, $1, $2, $3, $4, $5); + case 7: + return new Fn($0, $1, $2, $3, $4, $5, $6); + case 8: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7); + case 9: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8); + case 10: + return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9); + } + })); + }); + + /** + * Accepts at least three functions and returns a new function. When invoked, this new + * function will invoke the first function, `after`, passing as its arguments the + * results of invoking the subsequent functions with whatever arguments are passed to + * the new function. + * + * @func + * @memberOf R + * @category Function + * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z) + * @param {Function} after A function. `after` will be invoked with the return values of + * `fn1` and `fn2` as its arguments. + * @param {...Function} functions A variable number of functions. + * @return {Function} A new function. + * @example + * + * var add = function(a, b) { return a + b; }; + * var multiply = function(a, b) { return a * b; }; + * var subtract = function(a, b) { return a - b; }; + * + * //≅ multiply( add(1, 2), subtract(1, 2) ); + * R.converge(multiply, add, subtract)(1, 2); //=> -3 + * + * var add3 = function(a, b, c) { return a + b + c; }; + * R.converge(add3, multiply, add, subtract)(1, 2); //=> 4 + */ + var converge = curryN(3, function converge(after) { + var fns = _slice(arguments, 1); + return curryN(Math.max.apply(Math, pluck('length', fns)), function () { + var args = arguments; + var context = this; + return after.apply(context, _map(function (fn) { + return fn.apply(context, args); + }, fns)); + }); + }); + + /** + * Returns all but the first `n` elements of the given list, string, or + * transducer/transformer (or object with a `drop` method). + * + * @func + * @memberOf R + * @category List + * @see R.transduce + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n + * @param {*} list + * @return {*} + * @see R.take + * @example + * + * R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] + * R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz'] + * R.drop(3, ['foo', 'bar', 'baz']); //=> [] + * R.drop(4, ['foo', 'bar', 'baz']); //=> [] + * R.drop(3, 'ramda'); //=> 'da' + */ + var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) { + return slice(Math.max(0, n), Infinity, xs); + })); + + /** + * Returns a list containing all but the last `n` elements of the given `list`. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n The number of elements of `xs` to skip. + * @param {Array} xs The collection to consider. + * @return {Array} + * @see R.takeLast + * @example + * + * R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] + * R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo'] + * R.dropLast(3, ['foo', 'bar', 'baz']); //=> [] + * R.dropLast(4, ['foo', 'bar', 'baz']); //=> [] + * R.dropLast(3, 'ramda'); //=> 'ra' + */ + var dropLast = _curry2(function dropLast(n, xs) { + return take(n < xs.length ? xs.length - n : 0, xs); + }); + + /** + * Returns a new list without any consecutively repeating elements. Equality is + * determined by applying the supplied predicate two consecutive elements. + * The first element in a series of equal element is the one being preserved. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a, a -> Boolean) -> [a] -> [a] + * @param {Function} pred A predicate used to test whether two items are equal. + * @param {Array} list The array to consider. + * @return {Array} `list` without repeating elements. + * @example + * + * function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); }; + * var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]; + * R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3] + */ + var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) { + var result = []; + var idx = 1; + var len = list.length; + if (len !== 0) { + result[0] = list[0]; + while (idx < len) { + if (!pred(last(result), list[idx])) { + result[result.length] = list[idx]; + } + idx += 1; + } + } + return result; + })); + + /** + * Reports whether two objects have the same value, in `R.equals` terms, + * for the specified property. Useful as a curried predicate. + * + * @func + * @memberOf R + * @category Object + * @sig k -> {k: v} -> {k: v} -> Boolean + * @param {String} prop The name of the property to compare + * @param {Object} obj1 + * @param {Object} obj2 + * @return {Boolean} + * + * @example + * + * var o1 = { a: 1, b: 2, c: 3, d: 4 }; + * var o2 = { a: 10, b: 20, c: 3, d: 40 }; + * R.eqProps('a', o1, o2); //=> false + * R.eqProps('c', o1, o2); //=> true + */ + var eqProps = _curry3(function eqProps(prop, obj1, obj2) { + return equals(obj1[prop], obj2[prop]); + }); + + /** + * Returns the position of the first occurrence of an item in an array, + * or -1 if the item is not included in the array. `R.equals` is used to + * determine equality. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Number + * @param {*} target The item to find. + * @param {Array} xs The array to search in. + * @return {Number} the index of the target, or -1 if the target is not found. + * @see R.lastIndexOf + * @example + * + * R.indexOf(3, [1,2,3,4]); //=> 2 + * R.indexOf(10, [1,2,3,4]); //=> -1 + */ + var indexOf = _curry2(function indexOf(target, xs) { + return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0); + }); + + /** + * Returns all but the last element of the given list or string. + * + * @func + * @memberOf R + * @category List + * @see R.last, R.head, R.tail + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.init([1, 2, 3]); //=> [1, 2] + * R.init([1, 2]); //=> [1] + * R.init([1]); //=> [] + * R.init([]); //=> [] + * + * R.init('abc'); //=> 'ab' + * R.init('ab'); //=> 'a' + * R.init('a'); //=> '' + * R.init(''); //=> '' + */ + var init = slice(0, -1); + + /** + * Returns `true` if all elements are unique, in `R.equals` terms, + * otherwise `false`. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> Boolean + * @param {Array} list The array to consider. + * @return {Boolean} `true` if all elements are unique, else `false`. + * @example + * + * R.isSet(['1', 1]); //=> true + * R.isSet([1, 1]); //=> false + * R.isSet([[42], [42]]); //=> false + */ + var isSet = _curry1(function isSet(list) { + var len = list.length; + var idx = 0; + while (idx < len) { + if (_indexOf(list, list[idx], idx + 1) >= 0) { + return false; + } + idx += 1; + } + return true; + }); + + /** + * Returns a lens for the given getter and setter functions. The getter "gets" + * the value of the focus; the setter "sets" the value of the focus. The setter + * should not mutate the data structure. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig (s -> a) -> ((a, s) -> s) -> Lens s a + * @param {Function} getter + * @param {Function} setter + * @return {Lens} + * @see R.view, R.set, R.over, R.lensIndex, R.lensProp + * @example + * + * var xLens = R.lens(R.prop('x'), R.assoc('x')); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} + */ + var lens = _curry2(function lens(getter, setter) { + return function (f) { + return function (s) { + return map(function (v) { + return setter(v, s); + }, f(getter(s))); + }; + }; + }); + + /** + * Returns a lens whose focus is the specified index. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig Number -> Lens s a + * @param {Number} n + * @return {Lens} + * @see R.view, R.set, R.over + * @example + * + * var headLens = R.lensIndex(0); + * + * R.view(headLens, ['a', 'b', 'c']); //=> 'a' + * R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c'] + * R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c'] + */ + var lensIndex = _curry1(function lensIndex(n) { + return lens(nth(n), update(n)); + }); + + /** + * Returns a lens whose focus is the specified property. + * + * @func + * @memberOf R + * @category Object + * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s + * @sig String -> Lens s a + * @param {String} k + * @return {Lens} + * @see R.view, R.set, R.over + * @example + * + * var xLens = R.lensProp('x'); + * + * R.view(xLens, {x: 1, y: 2}); //=> 1 + * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} + * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} + */ + var lensProp = _curry1(function lensProp(k) { + return lens(prop(k), assoc(k)); + }); + + /** + * "lifts" a function to be the specified arity, so that it may "map over" that many + * lists (or other Functors). + * + * @func + * @memberOf R + * @see R.lift + * @category Function + * @sig Number -> (*... -> *) -> ([*]... -> [*]) + * @param {Function} fn The function to lift into higher context + * @return {Function} The function `fn` applicable to mappable objects. + * @example + * + * var madd3 = R.liftN(3, R.curryN(3, function() { + * return R.reduce(R.add, 0, arguments); + * })); + * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] + */ + var liftN = _curry2(function liftN(arity, fn) { + var lifted = curryN(arity, fn); + return curryN(arity, function () { + return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1)); + }); + }); + + /** + * Returns the mean of the given list of numbers. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list + * @return {Number} + * @example + * + * R.mean([2, 7, 9]); //=> 6 + * R.mean([]); //=> NaN + */ + var mean = _curry1(function mean(list) { + return sum(list) / list.length; + }); + + /** + * Returns the median of the given list of numbers. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list + * @return {Number} + * @example + * + * R.median([2, 9, 7]); //=> 7 + * R.median([7, 2, 10, 9]); //=> 8 + * R.median([]); //=> NaN + */ + var median = _curry1(function median(list) { + var len = list.length; + if (len === 0) { + return NaN; + } + var width = 2 - len % 2; + var idx = (len - width) / 2; + return mean(_slice(list).sort(function (a, b) { + return a < b ? -1 : a > b ? 1 : 0; + }).slice(idx, idx + width)); + }); + + /** + * Merges a list of objects together into one object. + * + * @func + * @memberOf R + * @category List + * @sig [{k: v}] -> {k: v} + * @param {Array} list An array of objects + * @return {Object} A merged object. + * @see R.reduce + * @example + * + * R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3} + * R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2} + */ + var mergeAll = _curry1(function mergeAll(list) { + return reduce(merge, {}, list); + }); + + /** + * Performs left-to-right function composition. The leftmost function may have + * any arity; the remaining functions must be unary. + * + * In some libraries this function is named `sequence`. + * + * @func + * @memberOf R + * @category Function + * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.compose + * @example + * + * var f = R.pipe(Math.pow, R.negate, R.inc); + * + * f(3, 4); // -(3^4) + 1 + */ + var pipe = function pipe() { + if (arguments.length === 0) { + throw new Error('pipe requires at least one argument'); + } + return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments))); + }; + + /** + * Performs left-to-right composition of one or more Promise-returning + * functions. The leftmost function may have any arity; the remaining + * functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z) + * @param {...Function} functions + * @return {Function} + * @see R.composeP + * @example + * + * // followersForUser :: String -> Promise [User] + * var followersForUser = R.pipeP(db.getUserById, db.getFollowers); + */ + var pipeP = function pipeP() { + if (arguments.length === 0) { + throw new Error('pipeP requires at least one argument'); + } + return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments))); + }; + + /** + * Multiplies together all the elements of a list. + * + * @func + * @memberOf R + * @category Math + * @sig [Number] -> Number + * @param {Array} list An array of numbers + * @return {Number} The product of all the numbers in the list. + * @see R.reduce + * @example + * + * R.product([2,4,6,8,100,1]); //=> 38400 + */ + var product = reduce(multiply, 1); + + /** + * Reasonable analog to SQL `select` statement. + * + * @func + * @memberOf R + * @category Object + * @category Relation + * @sig [k] -> [{k: v}] -> [{k: v}] + * @param {Array} props The property names to project + * @param {Array} objs The objects to query + * @return {Array} An array of objects with just the `props` properties. + * @example + * + * var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2}; + * var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7}; + * var kids = [abby, fred]; + * R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}] + */ + // passing `identity` gives correct arity + var project = useWith(_map, pickAll, identity); + + /** + * Returns a new list containing the last `n` elements of the given list. + * If `n > list.length`, returns a list of `list.length` elements. + * + * @func + * @memberOf R + * @category List + * @sig Number -> [a] -> [a] + * @sig Number -> String -> String + * @param {Number} n The number of elements to return. + * @param {Array} xs The collection to consider. + * @return {Array} + * @see R.dropLast + * @example + * + * R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz'] + * R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz'] + * R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] + * R.takeLast(3, 'ramda'); //=> 'mda' + */ + var takeLast = _curry2(function takeLast(n, xs) { + return drop(n >= 0 ? xs.length - n : 0, xs); + }); + + var _contains = function _contains(a, list) { + return _indexOf(list, a, 0) >= 0; + }; + + // mapPairs :: (Object, [String]) -> [String] + // Function, RegExp, user-defined types + var _toString = function _toString(x, seen) { + var recur = function recur(y) { + var xs = seen.concat([x]); + return _contains(y, xs) ? '' : _toString(y, xs); + }; + // mapPairs :: (Object, [String]) -> [String] + var mapPairs = function (obj, keys) { + return _map(function (k) { + return _quote(k) + ': ' + recur(obj[k]); + }, keys.slice().sort()); + }; + switch (Object.prototype.toString.call(x)) { + case '[object Arguments]': + return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))'; + case '[object Array]': + return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\d+$/), keys(x)))).join(', ') + ']'; + case '[object Boolean]': + return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString(); + case '[object Date]': + return 'new Date(' + _quote(_toISOString(x)) + ')'; + case '[object Null]': + return 'null'; + case '[object Number]': + return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10); + case '[object String]': + return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x); + case '[object Undefined]': + return 'undefined'; + default: + return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types + '{' + mapPairs(x, keys(x)).join(', ') + '}'; + } + }; + + /** + * Turns a list of Functors into a Functor of a list. + * + * @func + * @memberOf R + * @category List + * @see R.commuteMap + * @sig Functor f => (x -> f x) -> [f a] -> f [a] + * @param {Function} of A function that returns the data type to return + * @param {Array} list An array of functors of the same type + * @return {*} + * @example + * + * R.commute(R.of, [[1], [2, 3]]); //=> [[1, 2], [1, 3]] + * R.commute(R.of, [[1, 2], [3]]); //=> [[1, 3], [2, 3]] + * R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]] + * R.commute(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3]) + * R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() + */ + var commute = commuteMap(identity); + + /** + * Performs right-to-left function composition. The rightmost function may have + * any arity; the remaining functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.pipe + * @example + * + * var f = R.compose(R.inc, R.negate, Math.pow); + * + * f(3, 4); // -(3^4) + 1 + */ + var compose = function compose() { + if (arguments.length === 0) { + throw new Error('compose requires at least one argument'); + } + return pipe.apply(this, reverse(arguments)); + }; + + /** + * Returns the right-to-left Kleisli composition of the provided functions, + * each of which must return a value of a type supported by [`chain`](#chain). + * + * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`. + * + * @func + * @memberOf R + * @category Function + * @see R.pipeK + * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z) + * @param {...Function} + * @return {Function} + * @example + * + * // parseJson :: String -> Maybe * + * // get :: String -> Object -> Maybe * + * + * // getStateCode :: Maybe String -> Maybe String + * var getStateCode = R.composeK( + * R.compose(Maybe.of, R.toUpper), + * get('state'), + * get('address'), + * get('user'), + * parseJson + * ); + * + * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}')); + * //=> Just('NY') + * getStateCode(Maybe.of('[Invalid JSON]')); + * //=> Nothing() + */ + var composeK = function composeK() { + return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments)); + }; + + /** + * Performs right-to-left composition of one or more Promise-returning + * functions. The rightmost function may have any arity; the remaining + * functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z) + * @param {...Function} functions + * @return {Function} + * @see R.pipeP + * @example + * + * // followersForUser :: String -> Promise [User] + * var followersForUser = R.composeP(db.getFollowers, db.getUserById); + */ + var composeP = function composeP() { + if (arguments.length === 0) { + throw new Error('composeP requires at least one argument'); + } + return pipeP.apply(this, reverse(arguments)); + }; + + /** + * Wraps a constructor function inside a curried function that can be called with the same + * arguments and returns the same type. + * + * @func + * @memberOf R + * @category Function + * @sig (* -> {*}) -> (* -> {*}) + * @param {Function} Fn The constructor function to wrap. + * @return {Function} A wrapped, curried constructor function. + * @example + * + * // Constructor function + * var Widget = function(config) { + * // ... + * }; + * Widget.prototype = { + * // ... + * }; + * var allConfigs = [ + * // ... + * ]; + * R.map(R.construct(Widget), allConfigs); // a list of Widgets + */ + var construct = _curry1(function construct(Fn) { + return constructN(Fn.length, Fn); + }); + + /** + * Returns `true` if the specified value is equal, in `R.equals` terms, + * to at least one element of the given list; `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Boolean + * @param {Object} a The item to compare against. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the item is in the list, `false` otherwise. + * + * @example + * + * R.contains(3, [1, 2, 3]); //=> true + * R.contains(4, [1, 2, 3]); //=> false + * R.contains([42], [[42]]); //=> true + */ + var contains = _curry2(_contains); + + /** + * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @return {Array} The elements in `list1` that are not in `list2`. + * @see R.differenceWith + * @example + * + * R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2] + * R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5] + */ + var difference = _curry2(function difference(first, second) { + var out = []; + var idx = 0; + var firstLen = first.length; + while (idx < firstLen) { + if (!_contains(first[idx], second) && !_contains(first[idx], out)) { + out[out.length] = first[idx]; + } + idx += 1; + } + return out; + }); + + /** + * Returns a new list without any consecutively repeating elements. + * `R.equals` is used to determine equality. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The array to consider. + * @return {Array} `list` without repeating elements. + * @example + * + * R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2] + */ + var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals))); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} list1 The first list. + * @param {Array} list2 The second list. + * @see R.intersectionWith + * @return {Array} The list of elements found in both `list1` and `list2`. + * @example + * + * R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3] + */ + var intersection = _curry2(function intersection(list1, list2) { + return uniq(_filter(flip(_contains)(list1), list2)); + }); + + /** + * "lifts" a function of arity > 1 so that it may "map over" an Array or + * other Functor. + * + * @func + * @memberOf R + * @see R.liftN + * @category Function + * @sig (*... -> *) -> ([*]... -> [*]) + * @param {Function} fn The function to lift into higher context + * @return {Function} The function `fn` applicable to mappable objects. + * @example + * + * var madd3 = R.lift(R.curry(function(a, b, c) { + * return a + b + c; + * })); + * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] + * + * var madd5 = R.lift(R.curry(function(a, b, c, d, e) { + * return a + b + c + d + e; + * })); + * madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24] + */ + var lift = _curry1(function lift(fn) { + return liftN(fn.length, fn); + }); + + /** + * Returns a partial copy of an object omitting the keys specified. + * + * @func + * @memberOf R + * @category Object + * @sig [String] -> {String: *} -> {String: *} + * @param {Array} names an array of String property names to omit from the new object + * @param {Object} obj The object to copy from + * @return {Object} A new object with properties from `names` not on it. + * @see R.pick + * @example + * + * R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3} + */ + var omit = _curry2(function omit(names, obj) { + var result = {}; + for (var prop in obj) { + if (!_contains(prop, names)) { + result[prop] = obj[prop]; + } + } + return result; + }); + + /** + * Returns the left-to-right Kleisli composition of the provided functions, + * each of which must return a value of a type supported by [`chain`](#chain). + * + * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`. + * + * @func + * @memberOf R + * @category Function + * @see R.composeK + * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z) + * @param {...Function} + * @return {Function} + * @example + * + * // parseJson :: String -> Maybe * + * // get :: String -> Object -> Maybe * + * + * // getStateCode :: Maybe String -> Maybe String + * var getStateCode = R.pipeK( + * parseJson, + * get('user'), + * get('address'), + * get('state'), + * R.compose(Maybe.of, R.toUpper) + * ); + * + * getStateCode(Maybe.of('{"user":{"address":{"state":"ny"}}}')); + * //=> Just('NY') + * getStateCode(Maybe.of('[Invalid JSON]')); + * //=> Nothing() + */ + var pipeK = function pipeK() { + return composeK.apply(this, reverse(arguments)); + }; + + /** + * Returns the string representation of the given value. `eval`'ing the output + * should result in a value equivalent to the input value. Many of the built-in + * `toString` methods do not satisfy this requirement. + * + * If the given value is an `[object Object]` with a `toString` method other + * than `Object.prototype.toString`, this method is invoked with no arguments + * to produce the return value. This means user-defined constructor functions + * can provide a suitable `toString` method. For example: + * + * function Point(x, y) { + * this.x = x; + * this.y = y; + * } + * + * Point.prototype.toString = function() { + * return 'new Point(' + this.x + ', ' + this.y + ')'; + * }; + * + * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)' + * + * @func + * @memberOf R + * @category String + * @sig * -> String + * @param {*} val + * @return {String} + * @example + * + * R.toString(42); //=> '42' + * R.toString('abc'); //=> '"abc"' + * R.toString([1, 2, 3]); //=> '[1, 2, 3]' + * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}' + * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")' + */ + var toString = _curry1(function toString(val) { + return _toString(val, []); + }); + + /** + * Combines two lists into a set (i.e. no duplicates) composed of the + * elements of each list. + * + * @func + * @memberOf R + * @category Relation + * @sig [a] -> [a] -> [a] + * @param {Array} as The first list. + * @param {Array} bs The second list. + * @return {Array} The first and second lists concatenated, with + * duplicates removed. + * @example + * + * R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4] + */ + var union = _curry2(compose(uniq, _concat)); + + /** + * Returns a new list containing only one copy of each element in the + * original list, based upon the value returned by applying the supplied + * function to each list element. Prefers the first item if the supplied + * function produces the same value on two items. `R.equals` is used for + * comparison. + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [a] + * @param {Function} fn A function used to produce a value to use during comparisons. + * @param {Array} list The array to consider. + * @return {Array} The list of unique items. + * @example + * + * R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10] + */ + var uniqBy = _curry2(function uniqBy(fn, list) { + var idx = 0, applied = [], result = [], appliedItem, item; + while (idx < list.length) { + item = list[idx]; + appliedItem = fn(item); + if (!_contains(appliedItem, applied)) { + result.push(item); + applied.push(appliedItem); + } + idx += 1; + } + return result; + }); + + /** + * Turns a named method with a specified arity into a function + * that can be called directly supplied with arguments and a target object. + * + * The returned function is curried and accepts `arity + 1` parameters where + * the final parameter is the target object. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *) + * @param {Number} arity Number of arguments the returned function should take + * before the target object. + * @param {Function} method Name of the method to call. + * @return {Function} A new curried function. + * @example + * + * var sliceFrom = R.invoker(1, 'slice'); + * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm' + * var sliceFrom6 = R.invoker(2, 'slice')(6); + * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh' + */ + var invoker = _curry2(function invoker(arity, method) { + return curryN(arity + 1, function () { + var target = arguments[arity]; + if (target != null && is(Function, target[method])) { + return target[method].apply(target, _slice(arguments, 0, arity)); + } + throw new TypeError(toString(target) + ' does not have a method named "' + method + '"'); + }); + }); + + /** + * Returns a string made by inserting the `separator` between each + * element and concatenating all the elements into a single string. + * + * @func + * @memberOf R + * @category List + * @sig String -> [a] -> String + * @param {Number|String} separator The string used to separate the elements. + * @param {Array} xs The elements to join into a string. + * @return {String} str The string made by concatenating `xs` with `separator`. + * @see R.split + * @example + * + * var spacer = R.join(' '); + * spacer(['a', 2, 3.4]); //=> 'a 2 3.4' + * R.join('|', [1, 2, 3]); //=> '1|2|3' + */ + var join = invoker(1, 'join'); + + /** + * Creates a new function that, when invoked, caches the result of calling `fn` for a given + * argument set and returns the result. Subsequent calls to the memoized `fn` with the same + * argument set will not result in an additional call to `fn`; instead, the cached result + * for that set of arguments will be returned. + * + * @func + * @memberOf R + * @category Function + * @sig (*... -> a) -> (*... -> a) + * @param {Function} fn The function to memoize. + * @return {Function} Memoized version of `fn`. + * @example + * + * var count = 0; + * var factorial = R.memoize(function(n) { + * count += 1; + * return R.product(R.range(1, n + 1)); + * }); + * factorial(5); //=> 120 + * factorial(5); //=> 120 + * factorial(5); //=> 120 + * count; //=> 1 + */ + var memoize = _curry1(function memoize(fn) { + var cache = {}; + return function () { + var key = toString(arguments); + if (!_has(key, cache)) { + cache[key] = fn.apply(this, arguments); + } + return cache[key]; + }; + }); + + /** + * Splits a string into an array of strings based on the given + * separator. + * + * @func + * @memberOf R + * @category String + * @sig String -> String -> [String] + * @param {String} sep The separator string. + * @param {String} str The string to separate into an array. + * @return {Array} The array of strings from `str` separated by `str`. + * @see R.join + * @example + * + * var pathComponents = R.split('/'); + * R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node'] + * + * R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd'] + */ + var split = invoker(1, 'split'); + + /** + * The lower case version of a string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to lower case. + * @return {String} The lower case version of `str`. + * @see R.toUpper + * @example + * + * R.toLower('XYZ'); //=> 'xyz' + */ + var toLower = invoker(0, 'toLowerCase'); + + /** + * The upper case version of a string. + * + * @func + * @memberOf R + * @category String + * @sig String -> String + * @param {String} str The string to upper case. + * @return {String} The upper case version of `str`. + * @see R.toLower + * @example + * + * R.toUpper('abc'); //=> 'ABC' + */ + var toUpper = invoker(0, 'toUpperCase'); + + var R = { + F: F, + T: T, + __: __, + add: add, + addIndex: addIndex, + adjust: adjust, + all: all, + allPass: allPass, + always: always, + and: and, + any: any, + anyPass: anyPass, + ap: ap, + aperture: aperture, + append: append, + apply: apply, + assoc: assoc, + assocPath: assocPath, + binary: binary, + bind: bind, + both: both, + call: call, + chain: chain, + clone: clone, + commute: commute, + commuteMap: commuteMap, + comparator: comparator, + complement: complement, + compose: compose, + composeK: composeK, + composeP: composeP, + concat: concat, + cond: cond, + construct: construct, + constructN: constructN, + contains: contains, + containsWith: containsWith, + converge: converge, + countBy: countBy, + createMapEntry: createMapEntry, + curry: curry, + curryN: curryN, + dec: dec, + defaultTo: defaultTo, + difference: difference, + differenceWith: differenceWith, + dissoc: dissoc, + dissocPath: dissocPath, + divide: divide, + drop: drop, + dropLast: dropLast, + dropLastWhile: dropLastWhile, + dropRepeats: dropRepeats, + dropRepeatsWith: dropRepeatsWith, + dropWhile: dropWhile, + either: either, + empty: empty, + eqProps: eqProps, + equals: equals, + evolve: evolve, + filter: filter, + find: find, + findIndex: findIndex, + findLast: findLast, + findLastIndex: findLastIndex, + flatten: flatten, + flip: flip, + forEach: forEach, + fromPairs: fromPairs, + functions: functions, + functionsIn: functionsIn, + groupBy: groupBy, + gt: gt, + gte: gte, + has: has, + hasIn: hasIn, + head: head, + identical: identical, + identity: identity, + ifElse: ifElse, + inc: inc, + indexOf: indexOf, + init: init, + insert: insert, + insertAll: insertAll, + intersection: intersection, + intersectionWith: intersectionWith, + intersperse: intersperse, + into: into, + invert: invert, + invertObj: invertObj, + invoker: invoker, + is: is, + isArrayLike: isArrayLike, + isEmpty: isEmpty, + isNil: isNil, + isSet: isSet, + join: join, + keys: keys, + keysIn: keysIn, + last: last, + lastIndexOf: lastIndexOf, + length: length, + lens: lens, + lensIndex: lensIndex, + lensProp: lensProp, + lift: lift, + liftN: liftN, + lt: lt, + lte: lte, + map: map, + mapAccum: mapAccum, + mapAccumRight: mapAccumRight, + mapObj: mapObj, + mapObjIndexed: mapObjIndexed, + match: match, + mathMod: mathMod, + max: max, + maxBy: maxBy, + mean: mean, + median: median, + memoize: memoize, + merge: merge, + mergeAll: mergeAll, + min: min, + minBy: minBy, + modulo: modulo, + multiply: multiply, + nAry: nAry, + negate: negate, + none: none, + not: not, + nth: nth, + nthArg: nthArg, + nthChar: nthChar, + nthCharCode: nthCharCode, + of: of, + omit: omit, + once: once, + or: or, + over: over, + partial: partial, + partialRight: partialRight, + partition: partition, + path: path, + pathEq: pathEq, + pick: pick, + pickAll: pickAll, + pickBy: pickBy, + pipe: pipe, + pipeK: pipeK, + pipeP: pipeP, + pluck: pluck, + prepend: prepend, + product: product, + project: project, + prop: prop, + propEq: propEq, + propIs: propIs, + propOr: propOr, + propSatisfies: propSatisfies, + props: props, + range: range, + reduce: reduce, + reduceRight: reduceRight, + reduced: reduced, + reject: reject, + remove: remove, + repeat: repeat, + replace: replace, + reverse: reverse, + scan: scan, + set: set, + slice: slice, + sort: sort, + sortBy: sortBy, + split: split, + splitEvery: splitEvery, + subtract: subtract, + sum: sum, + tail: tail, + take: take, + takeLast: takeLast, + takeLastWhile: takeLastWhile, + takeWhile: takeWhile, + tap: tap, + test: test, + times: times, + toLower: toLower, + toPairs: toPairs, + toPairsIn: toPairsIn, + toString: toString, + toUpper: toUpper, + transduce: transduce, + trim: trim, + type: type, + unapply: unapply, + unary: unary, + uncurryN: uncurryN, + unfold: unfold, + union: union, + unionWith: unionWith, + uniq: uniq, + uniqBy: uniqBy, + uniqWith: uniqWith, + unnest: unnest, + update: update, + useWith: useWith, + values: values, + valuesIn: valuesIn, + view: view, + where: where, + whereEq: whereEq, + wrap: wrap, + xprod: xprod, + zip: zip, + zipObj: zipObj, + zipWith: zipWith + }; + + /* TEST_ENTRY_POINT */ + + if (typeof exports === 'object') { + module.exports = R; + } else if (typeof define === 'function' && define.amd) { + define(function() { return R; }); + } else { + this.R = R; + } + +}.call(this)); + +},{}],9:[function(require,module,exports){ +var always = require('./always'); + + +/** + * A function that always returns `true`. Any passed in parameters are ignored. + * + * @func + * @memberOf R + * @category Function + * @sig * -> true + * @return {Boolean} `true`. + * @see R.always, R.F + * @example + * + * R.T(); //=> true + */ +module.exports = always(true); + +},{"./always":12}],10:[function(require,module,exports){ +/** + * A special placeholder value used to specify "gaps" within curried functions, + * allowing partial application of any combination of arguments, + * regardless of their positions. + * + * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2, _)(1, 3)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @constant + * @memberOf R + * @category Function + * @example + * + * var greet = R.replace('{name}', R.__, 'Hello, {name}!'); + * greet('Alice'); //=> 'Hello, Alice!' + */ +module.exports = {'@@functional/placeholder': true}; + +},{}],11:[function(require,module,exports){ +var _concat = require('./internal/_concat'); +var _curry3 = require('./internal/_curry3'); + +/** + * Applies a function to the value at the given index of an array, + * returning a new copy of the array with the element at the given + * index replaced with the result of the function application. + * @see R.update + * + * @func + * @memberOf R + * @category List + * @sig (a -> a) -> Number -> [a] -> [a] + * @param {Function} fn The function to apply. + * @param {Number} idx The index. + * @param {Array|Arguments} list An array-like object whose value + * at the supplied index will be replaced. + * @return {Array} A copy of the supplied array-like object with + * the element at index `idx` replaced with the value + * returned by applying `fn` to the existing element. + * @example + * + * R.adjust(R.add(10), 1, [0, 1, 2]); //=> [0, 11, 2] + * R.adjust(R.add(10))(1)([0, 1, 2]); //=> [0, 11, 2] + */ +module.exports = _curry3(function adjust(fn, idx, list) { + if (idx >= list.length || idx < -list.length) { + return list; + } + var start = idx < 0 ? list.length : 0; + var _idx = start + idx; + var _list = _concat(list); + _list[_idx] = fn(list[_idx]); + return _list; +}); + +},{"./internal/_concat":28,"./internal/_curry3":32}],12:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); + + +/** + * Returns a function that always returns the given value. Note that for + * non-primitives the value returned is a reference to the original value. + * + * This function is known as `const`, `constant`, or `K` (for K combinator) + * in other languages and libraries. + * + * @func + * @memberOf R + * @category Function + * @sig a -> (* -> a) + * @param {*} val The value to wrap in a function + * @return {Function} A Function :: * -> val. + * @example + * + * var t = R.always('Tee'); + * t(); //=> 'Tee' + */ +module.exports = _curry1(function always(val) { + return function() { + return val; + }; +}); + +},{"./internal/_curry1":30}],13:[function(require,module,exports){ +var _concat = require('./internal/_concat'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns a new list containing the contents of the given list, followed by the given + * element. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> [a] + * @param {*} el The element to add to the end of the new list. + * @param {Array} list The list whose contents will be added to the beginning of the output + * list. + * @return {Array} A new list containing the contents of the old list followed by `el`. + * @see R.prepend + * @example + * + * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests'] + * R.append('tests', []); //=> ['tests'] + * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] + */ +module.exports = _curry2(function append(el, list) { + return _concat(list, [el]); +}); + +},{"./internal/_concat":28,"./internal/_curry2":31}],14:[function(require,module,exports){ +var _curry3 = require('./internal/_curry3'); + + +/** + * Makes a shallow clone of an object, setting or overriding the specified + * property with the given value. Note that this copies and flattens + * prototype properties onto the new object as well. All non-primitive + * properties are copied by reference. + * + * @func + * @memberOf R + * @category Object + * @sig String -> a -> {k: v} -> {k: v} + * @param {String} prop the property name to set + * @param {*} val the new value + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original except for the specified property. + * @see R.dissoc + * @example + * + * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3} + */ +module.exports = _curry3(function assoc(prop, val, obj) { + var result = {}; + for (var p in obj) { + result[p] = obj[p]; + } + result[prop] = val; + return result; +}); + +},{"./internal/_curry3":32}],15:[function(require,module,exports){ +var _arity = require('./internal/_arity'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Creates a function that is bound to a context. + * Note: `R.bind` does not provide the additional argument-binding capabilities of + * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind). + * + * @func + * @memberOf R + * @category Function + * @category Object + * @see R.partial + * @sig (* -> *) -> {*} -> (* -> *) + * @param {Function} fn The function to bind to context + * @param {Object} thisObj The context to bind `fn` to + * @return {Function} A function that will execute in the context of `thisObj`. + */ +module.exports = _curry2(function bind(fn, thisObj) { + return _arity(fn.length, function() { + return fn.apply(thisObj, arguments); + }); +}); + +},{"./internal/_arity":24,"./internal/_curry2":31}],16:[function(require,module,exports){ +var pipe = require('./pipe'); +var reverse = require('./reverse'); + + +/** + * Performs right-to-left function composition. The rightmost function may have + * any arity; the remaining functions must be unary. + * + * @func + * @memberOf R + * @category Function + * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.pipe + * @example + * + * var f = R.compose(R.inc, R.negate, Math.pow); + * + * f(3, 4); // -(3^4) + 1 + */ +module.exports = function compose() { + if (arguments.length === 0) { + throw new Error('compose requires at least one argument'); + } + return pipe.apply(this, reverse(arguments)); +}; + +},{"./pipe":59,"./reverse":62}],17:[function(require,module,exports){ +var _contains = require('./internal/_contains'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns `true` if the specified value is equal, in `R.equals` terms, + * to at least one element of the given list; `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Boolean + * @param {Object} a The item to compare against. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the item is in the list, `false` otherwise. + * + * @example + * + * R.contains(3, [1, 2, 3]); //=> true + * R.contains(4, [1, 2, 3]); //=> false + * R.contains([42], [[42]]); //=> true + */ +module.exports = _curry2(_contains); + +},{"./internal/_contains":29,"./internal/_curry2":31}],18:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var curryN = require('./curryN'); + + +/** + * Returns a curried equivalent of the provided function. The curried + * function has two unusual capabilities. First, its arguments needn't + * be provided one at a time. If `f` is a ternary function and `g` is + * `R.curry(f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig (* -> a) -> (* -> a) + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curryN + * @example + * + * var addFourNumbers = function(a, b, c, d) { + * return a + b + c + d; + * }; + * + * var curriedAddFourNumbers = R.curry(addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry1(function curry(fn) { + return curryN(fn.length, fn); +}); + +},{"./curryN":19,"./internal/_curry1":30}],19:[function(require,module,exports){ +var _arity = require('./internal/_arity'); +var _curry1 = require('./internal/_curry1'); +var _curry2 = require('./internal/_curry2'); +var _curryN = require('./internal/_curryN'); + + +/** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry2(function curryN(length, fn) { + if (length === 1) { + return _curry1(fn); + } + return _arity(length, _curryN(length, [], fn)); +}); + +},{"./internal/_arity":24,"./internal/_curry1":30,"./internal/_curry2":31,"./internal/_curryN":33}],20:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _equals = require('./internal/_equals'); +var _hasMethod = require('./internal/_hasMethod'); + + +/** + * Returns `true` if its arguments are equivalent, `false` otherwise. + * Dispatches to an `equals` method if present. Handles cyclical data + * structures. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> b -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * R.equals(1, 1); //=> true + * R.equals(1, '1'); //=> false + * R.equals([1, 2, 3], [1, 2, 3]); //=> true + * + * var a = {}; a.v = a; + * var b = {}; b.v = b; + * R.equals(a, b); //=> true + */ +module.exports = _curry2(function equals(a, b) { + return _hasMethod('equals', a) ? a.equals(b) : + _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []); +}); + +},{"./internal/_curry2":31,"./internal/_equals":35,"./internal/_hasMethod":38}],21:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Creates a new object by recursively evolving a shallow copy of `object`, according to the + * `transformation` functions. All non-primitive properties are copied by reference. + * + * A `tranformation` function will not be invoked if its corresponding key does not exist in + * the evolved object. + * + * @func + * @memberOf R + * @category Object + * @sig {k: (v -> v)} -> {k: v} -> {k: v} + * @param {Object} transformations The object specifying transformation functions to apply + * to the object. + * @param {Object} object The object to be transformed. + * @return {Object} The transformed object. + * @example + * + * var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123}; + * var transformations = { + * firstName: R.trim, + * lastName: R.trim, // Will not get invoked. + * data: {elapsed: R.add(1), remaining: R.add(-1)} + * }; + * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} + */ +module.exports = _curry2(function evolve(transformations, object) { + var transformation, key, type, result = {}; + for (key in object) { + transformation = transformations[key]; + type = typeof transformation; + result[key] = type === 'function' ? transformation(object[key]) + : type === 'object' ? evolve(transformations[key], object[key]) + : object[key]; + } + return result; +}); + +},{"./internal/_curry2":31}],22:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _dispatchable = require('./internal/_dispatchable'); +var _filter = require('./internal/_filter'); +var _xfilter = require('./internal/_xfilter'); + + +/** + * Returns a new list containing only those items that match a given predicate function. + * The predicate function is passed one argument: *(value)*. + * + * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native + * `Array.prototype.filter` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.reject + * @example + * + * var isEven = function(n) { + * return n % 2 === 0; + * }; + * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4] + */ +module.exports = _curry2(_dispatchable('filter', _xfilter, _filter)); + +},{"./internal/_curry2":31,"./internal/_dispatchable":34,"./internal/_filter":36,"./internal/_xfilter":50}],23:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns true if its arguments are identical, false otherwise. Values are + * identical if they reference the same memory. `NaN` is identical to `NaN`; + * `0` and `-0` are not identical. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * var o = {}; + * R.identical(o, o); //=> true + * R.identical(1, 1); //=> true + * R.identical(1, '1'); //=> false + * R.identical([], []); //=> false + * R.identical(0, -0); //=> false + * R.identical(NaN, NaN); //=> true + */ +module.exports = _curry2(function identical(a, b) { + // SameValue algorithm + if (a === b) { // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + return a !== 0 || 1 / a === 1 / b; + } else { + // Step 6.a: NaN == NaN + return a !== a && b !== b; + } +}); + +},{"./internal/_curry2":31}],24:[function(require,module,exports){ +module.exports = function _arity(n, fn) { + // jshint unused:vars + switch (n) { + case 0: return function() { return fn.apply(this, arguments); }; + case 1: return function(a0) { return fn.apply(this, arguments); }; + case 2: return function(a0, a1) { return fn.apply(this, arguments); }; + case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; + case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; + case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; + case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; + case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; + case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; + case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; + case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; + default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); + } +}; + +},{}],25:[function(require,module,exports){ +var _isArray = require('./_isArray'); +var _slice = require('./_slice'); + + +/** + * Similar to hasMethod, this checks whether a function has a [methodname] + * function. If it isn't an array it will execute that function otherwise it will + * default to the ramda implementation. + * + * @private + * @param {Function} fn ramda implemtation + * @param {String} methodname property to check for a custom implementation + * @return {Object} Whatever the return value of the method is. + */ +module.exports = function _checkForMethod(methodname, fn) { + return function() { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + return (_isArray(obj) || typeof obj[methodname] !== 'function') ? + fn.apply(this, arguments) : + obj[methodname].apply(obj, _slice(arguments, 0, length - 1)); + }; +}; + +},{"./_isArray":40,"./_slice":46}],26:[function(require,module,exports){ +module.exports = function _cloneRegExp(pattern) { + return new RegExp(pattern.source, (pattern.global ? 'g' : '') + + (pattern.ignoreCase ? 'i' : '') + + (pattern.multiline ? 'm' : '') + + (pattern.sticky ? 'y' : '') + + (pattern.unicode ? 'u' : '')); +}; + +},{}],27:[function(require,module,exports){ +module.exports = function _complement(f) { + return function() { + return !f.apply(this, arguments); + }; +}; + +},{}],28:[function(require,module,exports){ +/** + * Private `concat` function to merge two array-like objects. + * + * @private + * @param {Array|Arguments} [set1=[]] An array-like object. + * @param {Array|Arguments} [set2=[]] An array-like object. + * @return {Array} A new, merged array. + * @example + * + * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] + */ +module.exports = function _concat(set1, set2) { + set1 = set1 || []; + set2 = set2 || []; + var idx; + var len1 = set1.length; + var len2 = set2.length; + var result = []; + + idx = 0; + while (idx < len1) { + result[result.length] = set1[idx]; + idx += 1; + } + idx = 0; + while (idx < len2) { + result[result.length] = set2[idx]; + idx += 1; + } + return result; +}; + +},{}],29:[function(require,module,exports){ +var _indexOf = require('./_indexOf'); + + +module.exports = function _contains(a, list) { + return _indexOf(list, a, 0) >= 0; +}; + +},{"./_indexOf":39}],30:[function(require,module,exports){ +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn.apply(this, arguments); + } + }; +}; + +},{}],31:[function(require,module,exports){ +var _curry1 = require('./_curry1'); + + +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry2(fn) { + return function f2(a, b) { + var n = arguments.length; + if (n === 0) { + return f2; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f2; + } else if (n === 1) { + return _curry1(function(b) { return fn(a, b); }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return f2; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function(a) { return fn(a, b); }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function(b) { return fn(a, b); }); + } else { + return fn(a, b); + } + }; +}; + +},{"./_curry1":30}],32:[function(require,module,exports){ +var _curry1 = require('./_curry1'); +var _curry2 = require('./_curry2'); + + +/** + * Optimized internal three-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry3(fn) { + return function f3(a, b, c) { + var n = arguments.length; + if (n === 0) { + return f3; + } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) { + return f3; + } else if (n === 1) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return f3; + } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) { + return _curry2(function(a, c) { return fn(a, b, c); }); + } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 2) { + return _curry1(function(c) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return f3; + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + b != null && b['@@functional/placeholder'] === true) { + return _curry2(function(a, b) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return _curry2(function(a, c) { return fn(a, b, c); }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && + c != null && c['@@functional/placeholder'] === true) { + return _curry2(function(b, c) { return fn(a, b, c); }); + } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) { + return _curry1(function(a) { return fn(a, b, c); }); + } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) { + return _curry1(function(b) { return fn(a, b, c); }); + } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) { + return _curry1(function(c) { return fn(a, b, c); }); + } else { + return fn(a, b, c); + } + }; +}; + +},{"./_curry1":30,"./_curry2":31}],33:[function(require,module,exports){ +var _arity = require('./_arity'); + + +/** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ +module.exports = function _curryN(length, received, fn) { + return function() { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && + (received[combinedIdx] == null || + received[combinedIdx]['@@functional/placeholder'] !== true || + argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn)); + }; +}; + +},{"./_arity":24}],34:[function(require,module,exports){ +var _isArray = require('./_isArray'); +var _isTransformer = require('./_isTransformer'); +var _slice = require('./_slice'); + + +/** + * Returns a function that dispatches with different strategies based on the + * object in list position (last argument). If it is an array, executes [fn]. + * Otherwise, if it has a function with [methodname], it will execute that + * function (functor case). Otherwise, if it is a transformer, uses transducer + * [xf] to return a new transformer (transducer case). Otherwise, it will + * default to executing [fn]. + * + * @private + * @param {String} methodname property to check for a custom implementation + * @param {Function} xf transducer to initialize if object is transformer + * @param {Function} fn default ramda implementation + * @return {Function} A function that dispatches on object in list position + */ +module.exports = function _dispatchable(methodname, xf, fn) { + return function() { + var length = arguments.length; + if (length === 0) { + return fn(); + } + var obj = arguments[length - 1]; + if (!_isArray(obj)) { + var args = _slice(arguments, 0, length - 1); + if (typeof obj[methodname] === 'function') { + return obj[methodname].apply(obj, args); + } + if (_isTransformer(obj)) { + var transducer = xf.apply(null, args); + return transducer(obj); + } + } + return fn.apply(this, arguments); + }; +}; + +},{"./_isArray":40,"./_isTransformer":41,"./_slice":46}],35:[function(require,module,exports){ +var _has = require('./_has'); +var identical = require('../identical'); +var keys = require('../keys'); +var type = require('../type'); + +// The algorithm used to handle cyclic structures is +// inspired by underscore's isEqual +module.exports = function _equals(a, b, stackA, stackB) { + var typeA = type(a); + if (typeA !== type(b)) { + return false; + } + + if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') { + return typeof a === 'object' ? + typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : + identical(a, b); + } + + if (identical(a, b)) { + return true; + } + + if (typeA === 'RegExp') { + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + return (a.source === b.source) && + (a.global === b.global) && + (a.ignoreCase === b.ignoreCase) && + (a.multiline === b.multiline) && + (a.sticky === b.sticky) && + (a.unicode === b.unicode); + } + + if (Object(a) === a) { + if (typeA === 'Date' && a.getTime() !== b.getTime()) { + return false; + } + + var keysA = keys(a); + if (keysA.length !== keys(b).length) { + return false; + } + + var idx = stackA.length - 1; + while (idx >= 0) { + if (stackA[idx] === a) { + return stackB[idx] === b; + } + idx -= 1; + } + + stackA[stackA.length] = a; + stackB[stackB.length] = b; + idx = keysA.length - 1; + while (idx >= 0) { + var key = keysA[idx]; + if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) { + return false; + } + idx -= 1; + } + stackA.pop(); + stackB.pop(); + return true; + } + return false; +}; + +},{"../identical":23,"../keys":56,"../type":67,"./_has":37}],36:[function(require,module,exports){ +module.exports = function _filter(fn, list) { + var idx = 0, len = list.length, result = []; + while (idx < len) { + if (fn(list[idx])) { + result[result.length] = list[idx]; + } + idx += 1; + } + return result; +}; + +},{}],37:[function(require,module,exports){ +module.exports = function _has(prop, obj) { + return Object.prototype.hasOwnProperty.call(obj, prop); +}; + +},{}],38:[function(require,module,exports){ +var _isArray = require('./_isArray'); + + +/** + * Private function that determines whether or not a provided object has a given method. + * Does not ignore methods stored on the object's prototype chain. Used for dynamically + * dispatching Ramda methods to non-Array objects. + * + * @private + * @param {String} methodName The name of the method to check for. + * @param {Object} obj The object to test. + * @return {Boolean} `true` has a given method, `false` otherwise. + * @example + * + * var person = { name: 'John' }; + * person.shout = function() { alert(this.name); }; + * + * _hasMethod('shout', person); //=> true + * _hasMethod('foo', person); //=> false + */ +module.exports = function _hasMethod(methodName, obj) { + return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function'; +}; + +},{"./_isArray":40}],39:[function(require,module,exports){ +var equals = require('../equals'); + + +module.exports = function _indexOf(list, item, from) { + var idx = from; + while (idx < list.length) { + if (equals(list[idx], item)) { + return idx; + } + idx += 1; + } + return -1; +}; + +},{"../equals":20}],40:[function(require,module,exports){ +/** + * Tests whether or not an object is an array. + * + * @private + * @param {*} val The object to test. + * @return {Boolean} `true` if `val` is an array, `false` otherwise. + * @example + * + * _isArray([]); //=> true + * _isArray(null); //=> false + * _isArray({}); //=> false + */ +module.exports = Array.isArray || function _isArray(val) { + return (val != null && + val.length >= 0 && + Object.prototype.toString.call(val) === '[object Array]'); +}; + +},{}],41:[function(require,module,exports){ +module.exports = function _isTransformer(obj) { + return typeof obj['@@transducer/step'] === 'function'; +}; + +},{}],42:[function(require,module,exports){ +module.exports = function _map(fn, list) { + var idx = 0, len = list.length, result = Array(len); + while (idx < len) { + result[idx] = fn(list[idx]); + idx += 1; + } + return result; +}; + +},{}],43:[function(require,module,exports){ +module.exports = function _pipe(f, g) { + return function() { + return g.call(this, f.apply(this, arguments)); + }; +}; + +},{}],44:[function(require,module,exports){ +module.exports = function _quote(s) { + return '"' + s.replace(/"/g, '\\"') + '"'; +}; + +},{}],45:[function(require,module,exports){ +var _xwrap = require('./_xwrap'); +var bind = require('../bind'); +var isArrayLike = require('../isArrayLike'); + + +module.exports = (function() { + function _arrayReduce(xf, acc, list) { + var idx = 0, len = list.length; + while (idx < len) { + acc = xf['@@transducer/step'](acc, list[idx]); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + idx += 1; + } + return xf['@@transducer/result'](acc); + } + + function _iterableReduce(xf, acc, iter) { + var step = iter.next(); + while (!step.done) { + acc = xf['@@transducer/step'](acc, step.value); + if (acc && acc['@@transducer/reduced']) { + acc = acc['@@transducer/value']; + break; + } + step = iter.next(); + } + return xf['@@transducer/result'](acc); + } + + function _methodReduce(xf, acc, obj) { + return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc)); + } + + var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator'; + return function _reduce(fn, acc, list) { + if (typeof fn === 'function') { + fn = _xwrap(fn); + } + if (isArrayLike(list)) { + return _arrayReduce(fn, acc, list); + } + if (typeof list.reduce === 'function') { + return _methodReduce(fn, acc, list); + } + if (list[symIterator] != null) { + return _iterableReduce(fn, acc, list[symIterator]()); + } + if (typeof list.next === 'function') { + return _iterableReduce(fn, acc, list); + } + throw new TypeError('reduce: list must be array or iterable'); + }; +})(); + +},{"../bind":15,"../isArrayLike":55,"./_xwrap":52}],46:[function(require,module,exports){ +/** + * An optimized, private array `slice` implementation. + * + * @private + * @param {Arguments|Array} args The array or arguments object to consider. + * @param {Number} [from=0] The array index to slice from, inclusive. + * @param {Number} [to=args.length] The array index to slice to, exclusive. + * @return {Array} A new, sliced array. + * @example + * + * _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3] + * + * var firstThreeArgs = function(a, b, c, d) { + * return _slice(arguments, 0, 3); + * }; + * firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3] + */ +module.exports = function _slice(args, from, to) { + switch (arguments.length) { + case 1: return _slice(args, 0, args.length); + case 2: return _slice(args, from, args.length); + default: + var list = []; + var idx = 0; + var len = Math.max(0, Math.min(args.length, to) - from); + while (idx < len) { + list[idx] = args[from + idx]; + idx += 1; + } + return list; + } +}; + +},{}],47:[function(require,module,exports){ +/** + * Polyfill from . + */ +module.exports = (function() { + var pad = function pad(n) { return (n < 10 ? '0' : '') + n; }; + + return typeof Date.prototype.toISOString === 'function' ? + function _toISOString(d) { + return d.toISOString(); + } : + function _toISOString(d) { + return ( + d.getUTCFullYear() + '-' + + pad(d.getUTCMonth() + 1) + '-' + + pad(d.getUTCDate()) + 'T' + + pad(d.getUTCHours()) + ':' + + pad(d.getUTCMinutes()) + ':' + + pad(d.getUTCSeconds()) + '.' + + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z' + ); + }; +}()); + +},{}],48:[function(require,module,exports){ +var _contains = require('./_contains'); +var _map = require('./_map'); +var _quote = require('./_quote'); +var _toISOString = require('./_toISOString'); +var keys = require('../keys'); +var reject = require('../reject'); +var test = require('../test'); + + +module.exports = function _toString(x, seen) { + var recur = function recur(y) { + var xs = seen.concat([x]); + return _contains(y, xs) ? '' : _toString(y, xs); + }; + + // mapPairs :: (Object, [String]) -> [String] + var mapPairs = function(obj, keys) { + return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort()); + }; + + switch (Object.prototype.toString.call(x)) { + case '[object Arguments]': + return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))'; + case '[object Array]': + return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\d+$/), keys(x)))).join(', ') + ']'; + case '[object Boolean]': + return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString(); + case '[object Date]': + return 'new Date(' + _quote(_toISOString(x)) + ')'; + case '[object Null]': + return 'null'; + case '[object Number]': + return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10); + case '[object String]': + return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x); + case '[object Undefined]': + return 'undefined'; + default: + return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' && + typeof x.toString === 'function' && x.toString() !== '[object Object]') ? + x.toString() : // Function, RegExp, user-defined types + '{' + mapPairs(x, keys(x)).join(', ') + '}'; + } +}; + +},{"../keys":56,"../reject":61,"../test":65,"./_contains":29,"./_map":42,"./_quote":44,"./_toISOString":47}],49:[function(require,module,exports){ +module.exports = { + init: function() { + return this.xf['@@transducer/init'](); + }, + result: function(result) { + return this.xf['@@transducer/result'](result); + } +}; + +},{}],50:[function(require,module,exports){ +var _curry2 = require('./_curry2'); +var _xfBase = require('./_xfBase'); + + +module.exports = (function() { + function XFilter(f, xf) { + this.xf = xf; + this.f = f; + } + XFilter.prototype['@@transducer/init'] = _xfBase.init; + XFilter.prototype['@@transducer/result'] = _xfBase.result; + XFilter.prototype['@@transducer/step'] = function(result, input) { + return this.f(input) ? this.xf['@@transducer/step'](result, input) : result; + }; + + return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); }); +})(); + +},{"./_curry2":31,"./_xfBase":49}],51:[function(require,module,exports){ +var _curry2 = require('./_curry2'); +var _xfBase = require('./_xfBase'); + + +module.exports = (function() { + function XMap(f, xf) { + this.xf = xf; + this.f = f; + } + XMap.prototype['@@transducer/init'] = _xfBase.init; + XMap.prototype['@@transducer/result'] = _xfBase.result; + XMap.prototype['@@transducer/step'] = function(result, input) { + return this.xf['@@transducer/step'](result, this.f(input)); + }; + + return _curry2(function _xmap(f, xf) { return new XMap(f, xf); }); +})(); + +},{"./_curry2":31,"./_xfBase":49}],52:[function(require,module,exports){ +module.exports = (function() { + function XWrap(fn) { + this.f = fn; + } + XWrap.prototype['@@transducer/init'] = function() { + throw new Error('init not implemented on XWrap'); + }; + XWrap.prototype['@@transducer/result'] = function(acc) { return acc; }; + XWrap.prototype['@@transducer/step'] = function(acc, x) { + return this.f(acc, x); + }; + + return function _xwrap(fn) { return new XWrap(fn); }; +}()); + +},{}],53:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _slice = require('./internal/_slice'); +var curryN = require('./curryN'); +var is = require('./is'); +var toString = require('./toString'); + + +/** + * Turns a named method with a specified arity into a function + * that can be called directly supplied with arguments and a target object. + * + * The returned function is curried and accepts `arity + 1` parameters where + * the final parameter is the target object. + * + * @func + * @memberOf R + * @category Function + * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *) + * @param {Number} arity Number of arguments the returned function should take + * before the target object. + * @param {Function} method Name of the method to call. + * @return {Function} A new curried function. + * @example + * + * var sliceFrom = R.invoker(1, 'slice'); + * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm' + * var sliceFrom6 = R.invoker(2, 'slice')(6); + * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh' + */ +module.exports = _curry2(function invoker(arity, method) { + return curryN(arity + 1, function() { + var target = arguments[arity]; + if (target != null && is(Function, target[method])) { + return target[method].apply(target, _slice(arguments, 0, arity)); + } + throw new TypeError(toString(target) + ' does not have a method named "' + method + '"'); + }); +}); + +},{"./curryN":19,"./internal/_curry2":31,"./internal/_slice":46,"./is":54,"./toString":66}],54:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * See if an object (`val`) is an instance of the supplied constructor. + * This function will check up the inheritance chain, if any. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> a -> Boolean + * @param {Object} ctor A constructor + * @param {*} val The value to test + * @return {Boolean} + * @example + * + * R.is(Object, {}); //=> true + * R.is(Number, 1); //=> true + * R.is(Object, 1); //=> false + * R.is(String, 's'); //=> true + * R.is(String, new String('')); //=> true + * R.is(Object, new String('')); //=> true + * R.is(Object, 's'); //=> false + * R.is(Number, {}); //=> false + */ +module.exports = _curry2(function is(Ctor, val) { + return val != null && val.constructor === Ctor || val instanceof Ctor; +}); + +},{"./internal/_curry2":31}],55:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _isArray = require('./internal/_isArray'); + + +/** + * Tests whether or not an object is similar to an array. + * + * @func + * @memberOf R + * @category Type + * @category List + * @sig * -> Boolean + * @param {*} x The object to test. + * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise. + * @example + * + * R.isArrayLike([]); //=> true + * R.isArrayLike(true); //=> false + * R.isArrayLike({}); //=> false + * R.isArrayLike({length: 10}); //=> false + * R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true + */ +module.exports = _curry1(function isArrayLike(x) { + if (_isArray(x)) { return true; } + if (!x) { return false; } + if (typeof x !== 'object') { return false; } + if (x instanceof String) { return false; } + if (x.nodeType === 1) { return !!x.length; } + if (x.length === 0) { return true; } + if (x.length > 0) { + return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1); + } + return false; +}); + +},{"./internal/_curry1":30,"./internal/_isArray":40}],56:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _has = require('./internal/_has'); + + +/** + * Returns a list containing the names of all the enumerable own + * properties of the supplied object. + * Note that the order of the output array is not guaranteed to be + * consistent across different JS platforms. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> [k] + * @param {Object} obj The object to extract properties from + * @return {Array} An array of the object's own properties. + * @example + * + * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] + */ +module.exports = (function() { + // cover IE < 9 keys issues + var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString'); + var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', + 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; + + var contains = function contains(list, item) { + var idx = 0; + while (idx < list.length) { + if (list[idx] === item) { + return true; + } + idx += 1; + } + return false; + }; + + return typeof Object.keys === 'function' ? + _curry1(function keys(obj) { + return Object(obj) !== obj ? [] : Object.keys(obj); + }) : + _curry1(function keys(obj) { + if (Object(obj) !== obj) { + return []; + } + var prop, ks = [], nIdx; + for (prop in obj) { + if (_has(prop, obj)) { + ks[ks.length] = prop; + } + } + if (hasEnumBug) { + nIdx = nonEnumerableProps.length - 1; + while (nIdx >= 0) { + prop = nonEnumerableProps[nIdx]; + if (_has(prop, obj) && !contains(ks, prop)) { + ks[ks.length] = prop; + } + nIdx -= 1; + } + } + return ks; + }); +}()); + +},{"./internal/_curry1":30,"./internal/_has":37}],57:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _dispatchable = require('./internal/_dispatchable'); +var _map = require('./internal/_map'); +var _xmap = require('./internal/_xmap'); + + +/** + * Returns a new list, constructed by applying the supplied function to every element of the + * supplied list. + * + * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the + * native `Array.prototype.map` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> b) -> [a] -> [b] + * @param {Function} fn The function to be called on every element of the input `list`. + * @param {Array} list The list to be iterated over. + * @return {Array} The new list. + * @example + * + * var double = function(x) { + * return x * 2; + * }; + * + * R.map(double, [1, 2, 3]); //=> [2, 4, 6] + */ +module.exports = _curry2(_dispatchable('map', _xmap, _map)); + +},{"./internal/_curry2":31,"./internal/_dispatchable":34,"./internal/_map":42,"./internal/_xmap":51}],58:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var keys = require('./keys'); + + +/** + * Create a new object with the own properties of `a` + * merged with the own properties of object `b`. + * + * @func + * @memberOf R + * @category Object + * @sig {k: v} -> {k: v} -> {k: v} + * @param {Object} a + * @param {Object} b + * @return {Object} + * @example + * + * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); + * //=> { 'name': 'fred', 'age': 40 } + * + * var resetToDefault = R.merge(R.__, {x: 0}); + * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} + */ +module.exports = _curry2(function merge(a, b) { + var result = {}; + var ks = keys(a); + var idx = 0; + while (idx < ks.length) { + result[ks[idx]] = a[ks[idx]]; + idx += 1; + } + ks = keys(b); + idx = 0; + while (idx < ks.length) { + result[ks[idx]] = b[ks[idx]]; + idx += 1; + } + return result; +}); + +},{"./internal/_curry2":31,"./keys":56}],59:[function(require,module,exports){ +var _pipe = require('./internal/_pipe'); +var curryN = require('./curryN'); +var reduce = require('./reduce'); +var tail = require('./tail'); + + +/** + * Performs left-to-right function composition. The leftmost function may have + * any arity; the remaining functions must be unary. + * + * In some libraries this function is named `sequence`. + * + * @func + * @memberOf R + * @category Function + * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z) + * @param {...Function} functions + * @return {Function} + * @see R.compose + * @example + * + * var f = R.pipe(Math.pow, R.negate, R.inc); + * + * f(3, 4); // -(3^4) + 1 + */ +module.exports = function pipe() { + if (arguments.length === 0) { + throw new Error('pipe requires at least one argument'); + } + return curryN(arguments[0].length, + reduce(_pipe, arguments[0], tail(arguments))); +}; + +},{"./curryN":19,"./internal/_pipe":43,"./reduce":60,"./tail":64}],60:[function(require,module,exports){ +var _curry3 = require('./internal/_curry3'); +var _reduce = require('./internal/_reduce'); + + +/** + * Returns a single item by iterating through the list, successively calling the iterator + * function and passing it an accumulator value and the current value from the array, and + * then passing the result to the next call. + * + * The iterator function receives two values: *(acc, value)*. It may use `R.reduced` to + * shortcut the iteration. + * + * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike + * the native `Array.prototype.reduce` method. For more details on this behavior, see: + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description + * @see R.reduced + * + * @func + * @memberOf R + * @category List + * @sig (a,b -> a) -> a -> [b] -> a + * @param {Function} fn The iterator function. Receives two values, the accumulator and the + * current element from the array. + * @param {*} acc The accumulator value. + * @param {Array} list The list to iterate over. + * @return {*} The final, accumulated value. + * @example + * + * var numbers = [1, 2, 3]; + * var add = function(a, b) { + * return a + b; + * }; + * + * R.reduce(add, 10, numbers); //=> 16 + */ +module.exports = _curry3(_reduce); + +},{"./internal/_curry3":32,"./internal/_reduce":45}],61:[function(require,module,exports){ +var _complement = require('./internal/_complement'); +var _curry2 = require('./internal/_curry2'); +var filter = require('./filter'); + + +/** + * Similar to `filter`, except that it keeps only values for which the given predicate + * function returns falsy. The predicate function is passed one argument: *(value)*. + * + * Acts as a transducer if a transformer is given in list position. + * @see R.transduce + * + * @func + * @memberOf R + * @category List + * @sig (a -> Boolean) -> [a] -> [a] + * @param {Function} fn The function called per iteration. + * @param {Array} list The collection to iterate over. + * @return {Array} The new filtered array. + * @see R.filter + * @example + * + * var isOdd = function(n) { + * return n % 2 === 1; + * }; + * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4] + */ +module.exports = _curry2(function reject(fn, list) { + return filter(_complement(fn), list); +}); + +},{"./filter":22,"./internal/_complement":27,"./internal/_curry2":31}],62:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _slice = require('./internal/_slice'); + + +/** + * Returns a new list with the same elements as the original list, just + * in the reverse order. + * + * @func + * @memberOf R + * @category List + * @sig [a] -> [a] + * @param {Array} list The list to reverse. + * @return {Array} A copy of the list in reverse order. + * @example + * + * R.reverse([1, 2, 3]); //=> [3, 2, 1] + * R.reverse([1, 2]); //=> [2, 1] + * R.reverse([1]); //=> [1] + * R.reverse([]); //=> [] + */ +module.exports = _curry1(function reverse(list) { + return _slice(list).reverse(); +}); + +},{"./internal/_curry1":30,"./internal/_slice":46}],63:[function(require,module,exports){ +var _checkForMethod = require('./internal/_checkForMethod'); +var _curry3 = require('./internal/_curry3'); + + +/** + * Returns the elements of the given list or string (or object with a `slice` + * method) from `fromIndex` (inclusive) to `toIndex` (exclusive). + * + * @func + * @memberOf R + * @category List + * @sig Number -> Number -> [a] -> [a] + * @sig Number -> Number -> String -> String + * @param {Number} fromIndex The start index (inclusive). + * @param {Number} toIndex The end index (exclusive). + * @param {*} list + * @return {*} + * @example + * + * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] + * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] + * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] + * R.slice(0, 3, 'ramda'); //=> 'ram' + */ +module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) { + return Array.prototype.slice.call(list, fromIndex, toIndex); +})); + +},{"./internal/_checkForMethod":25,"./internal/_curry3":32}],64:[function(require,module,exports){ +var _checkForMethod = require('./internal/_checkForMethod'); +var slice = require('./slice'); + + +/** + * Returns all but the first element of the given list or string (or object + * with a `tail` method). + * + * @func + * @memberOf R + * @category List + * @see R.head, R.init, R.last + * @sig [a] -> [a] + * @sig String -> String + * @param {*} list + * @return {*} + * @example + * + * R.tail([1, 2, 3]); //=> [2, 3] + * R.tail([1, 2]); //=> [2] + * R.tail([1]); //=> [] + * R.tail([]); //=> [] + * + * R.tail('abc'); //=> 'bc' + * R.tail('ab'); //=> 'b' + * R.tail('a'); //=> '' + * R.tail(''); //=> '' + */ +module.exports = _checkForMethod('tail', slice(1, Infinity)); + +},{"./internal/_checkForMethod":25,"./slice":63}],65:[function(require,module,exports){ +var _cloneRegExp = require('./internal/_cloneRegExp'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Determines whether a given string matches a given regular expression. + * + * @func + * @memberOf R + * @see R.match + * @category String + * @sig RegExp -> String -> Boolean + * @param {RegExp} pattern + * @param {String} str + * @return {Boolean} + * @example + * + * R.test(/^x/, 'xyz'); //=> true + * R.test(/^y/, 'xyz'); //=> false + */ +module.exports = _curry2(function test(pattern, str) { + return _cloneRegExp(pattern).test(str); +}); + +},{"./internal/_cloneRegExp":26,"./internal/_curry2":31}],66:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); +var _toString = require('./internal/_toString'); + + +/** + * Returns the string representation of the given value. `eval`'ing the output + * should result in a value equivalent to the input value. Many of the built-in + * `toString` methods do not satisfy this requirement. + * + * If the given value is an `[object Object]` with a `toString` method other + * than `Object.prototype.toString`, this method is invoked with no arguments + * to produce the return value. This means user-defined constructor functions + * can provide a suitable `toString` method. For example: + * + * function Point(x, y) { + * this.x = x; + * this.y = y; + * } + * + * Point.prototype.toString = function() { + * return 'new Point(' + this.x + ', ' + this.y + ')'; + * }; + * + * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)' + * + * @func + * @memberOf R + * @category String + * @sig * -> String + * @param {*} val + * @return {String} + * @example + * + * R.toString(42); //=> '42' + * R.toString('abc'); //=> '"abc"' + * R.toString([1, 2, 3]); //=> '[1, 2, 3]' + * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}' + * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")' + */ +module.exports = _curry1(function toString(val) { return _toString(val, []); }); + +},{"./internal/_curry1":30,"./internal/_toString":48}],67:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); + + +/** + * Gives a single-word string description of the (native) type of a value, returning such + * answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user + * Object types any further, reporting them all as 'Object'. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> String + * @param {*} val The value to test + * @return {String} + * @example + * + * R.type({}); //=> "Object" + * R.type(1); //=> "Number" + * R.type(false); //=> "Boolean" + * R.type('s'); //=> "String" + * R.type(null); //=> "Null" + * R.type([]); //=> "Array" + * R.type(/[A-z]/); //=> "RegExp" + */ +module.exports = _curry1(function type(val) { + return val === null ? 'Null' : + val === undefined ? 'Undefined' : + Object.prototype.toString.call(val).slice(8, -1); +}); + +},{"./internal/_curry1":30}],68:[function(require,module,exports){ +var VNode = require('./vnode'); +var is = require('./is'); + +module.exports = function h(sel, b, c) { + var data = {}, children, text, i; + if (arguments.length === 3) { + data = b; + if (is.array(c)) { children = c; } + else if (is.primitive(c)) { text = c; } + } else if (arguments.length === 2) { + if (is.array(b)) { children = b; } + else if (is.primitive(b)) { text = b; } + else { data = b; } + } + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]); + } + } + return VNode(sel, data, children, text, undefined); +}; + +},{"./is":69,"./vnode":76}],69:[function(require,module,exports){ +module.exports = { + array: Array.isArray, + primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; }, +}; + +},{}],70:[function(require,module,exports){ +var booleanAttrs = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "compact", "controls", "declare", + "default", "defaultchecked", "defaultmuted", "defaultselected", "defer", "disabled", "draggable", + "enabled", "formnovalidate", "hidden", "indeterminate", "inert", "ismap", "itemscope", "loop", "multiple", + "muted", "nohref", "noresize", "noshade", "novalidate", "nowrap", "open", "pauseonexit", "readonly", + "required", "reversed", "scoped", "seamless", "selected", "sortable", "spellcheck", "translate", + "truespeed", "typemustmatch", "visible"]; + +var booleanAttrsDict = {}; +for(var i=0, len = booleanAttrs.length; i < len; i++) { + booleanAttrsDict[booleanAttrs[i]] = true; +} + +function updateAttrs(oldVnode, vnode) { + var key, cur, old, elm = vnode.elm, + oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {}; + + // update modified attributes, add new attributes + for (key in attrs) { + cur = attrs[key]; + old = oldAttrs[key]; + if (old !== cur) { + // TODO: add support to namespaced attributes (setAttributeNS) + if(!cur && booleanAttrsDict[key]) + elm.removeAttribute(key); + else + elm.setAttribute(key, cur); + } + } + //remove removed attributes + // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value) + // the other option is to remove all attributes with value == undefined + for (key in oldAttrs) { + if (!(key in attrs)) { + elm.removeAttribute(key); + } + } +} + +module.exports = {create: updateAttrs, update: updateAttrs}; + +},{}],71:[function(require,module,exports){ +function updateClass(oldVnode, vnode) { + var cur, name, elm = vnode.elm, + oldClass = oldVnode.data.class || {}, + klass = vnode.data.class || {}; + for (name in klass) { + cur = klass[name]; + if (cur !== oldClass[name]) { + elm.classList[cur ? 'add' : 'remove'](name); + } + } +} + +module.exports = {create: updateClass, update: updateClass}; + +},{}],72:[function(require,module,exports){ +var is = require('../is'); + +function arrInvoker(arr) { + return function() { + // Special case when length is two, for performance + arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1)); + }; +} + +function fnInvoker(o) { + return function(ev) { o.fn(ev); }; +} + +function updateEventListeners(oldVnode, vnode) { + var name, cur, old, elm = vnode.elm, + oldOn = oldVnode.data.on || {}, on = vnode.data.on; + if (!on) return; + for (name in on) { + cur = on[name]; + old = oldOn[name]; + if (old === undefined) { + if (is.array(cur)) { + elm.addEventListener(name, arrInvoker(cur)); + } else { + cur = {fn: cur}; + on[name] = cur; + elm.addEventListener(name, fnInvoker(cur)); + } + } else if (is.array(old)) { + // Deliberately modify old array since it's captured in closure created with `arrInvoker` + old.length = cur.length; + for (var i = 0; i < old.length; ++i) old[i] = cur[i]; + on[name] = old; + } else { + old.fn = cur; + on[name] = old; + } + } +} + +module.exports = {create: updateEventListeners, update: updateEventListeners}; + +},{"../is":69}],73:[function(require,module,exports){ +function updateProps(oldVnode, vnode) { + var key, cur, old, elm = vnode.elm, + oldProps = oldVnode.data.props || {}, props = vnode.data.props || {}; + for (key in props) { + cur = props[key]; + old = oldProps[key]; + if (old !== cur) { + elm[key] = cur; + } + } +} + +module.exports = {create: updateProps, update: updateProps}; + +},{}],74:[function(require,module,exports){ +var raf = requestAnimationFrame || setTimeout; +var nextFrame = function(fn) { raf(function() { raf(fn); }); }; + +function setNextFrame(obj, prop, val) { + nextFrame(function() { obj[prop] = val; }); +} + +function updateStyle(oldVnode, vnode) { + var cur, name, elm = vnode.elm, + oldStyle = oldVnode.data.style || {}, + style = vnode.data.style || {}, + oldHasDel = 'delayed' in oldStyle; + for (name in style) { + cur = style[name]; + if (name === 'delayed') { + for (name in style.delayed) { + cur = style.delayed[name]; + if (!oldHasDel || cur !== oldStyle.delayed[name]) { + setNextFrame(elm.style, name, cur); + } + } + } else if (name !== 'remove' && cur !== oldStyle[name]) { + elm.style[name] = cur; + } + } +} + +function applyDestroyStyle(vnode) { + var style, name, elm = vnode.elm, s = vnode.data.style; + if (!s || !(style = s.destroy)) return; + for (name in style) { + elm.style[name] = style[name]; + } +} + +function applyRemoveStyle(vnode, rm) { + var s = vnode.data.style; + if (!s || !s.remove) { + rm(); + return; + } + var name, elm = vnode.elm, idx, i = 0, maxDur = 0, + compStyle, style = s.remove, amount = 0, applied = []; + for (name in style) { + applied.push(name); + elm.style[name] = style[name]; + } + compStyle = getComputedStyle(elm); + var props = compStyle['transition-property'].split(', '); + for (; i < props.length; ++i) { + if(applied.indexOf(props[i]) !== -1) amount++; + } + elm.addEventListener('transitionend', function(ev) { + if (ev.target === elm) --amount; + if (amount === 0) rm(); + }); +} + +module.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle}; + +},{}],75:[function(require,module,exports){ +// jshint newcap: false +/* global require, module, document, Element */ +'use strict'; + +var VNode = require('./vnode'); +var is = require('./is'); + +function isUndef(s) { return s === undefined; } +function isDef(s) { return s !== undefined; } + +function emptyNodeAt(elm) { + return VNode(elm.tagName, {}, [], undefined, elm); +} + +var emptyNode = VNode('', {}, [], undefined, undefined); + +var insertedVnodeQueue; + +function sameVnode(vnode1, vnode2) { + return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel; +} + +function createKeyToOldIdx(children, beginIdx, endIdx) { + var i, map = {}, key; + for (i = beginIdx; i <= endIdx; ++i) { + key = children[i].key; + if (isDef(key)) map[key] = i; + } + return map; +} + +function createRmCb(childElm, listeners) { + return function() { + if (--listeners === 0) childElm.parentElement.removeChild(childElm); + }; +} + +var hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post']; + +function init(modules) { + var i, j, cbs = {}; + for (i = 0; i < hooks.length; ++i) { + cbs[hooks[i]] = []; + for (j = 0; j < modules.length; ++j) { + if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]); + } + } + + function createElm(vnode) { + var i, data = vnode.data; + if (isDef(data)) { + if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode); + if (isDef(i = data.vnode)) vnode = i; + } + var elm, children = vnode.children, sel = vnode.sel; + if (isDef(sel)) { + // Parse selector + var hashIdx = sel.indexOf('#'); + var dotIdx = sel.indexOf('.', hashIdx); + var hash = hashIdx > 0 ? hashIdx : sel.length; + var dot = dotIdx > 0 ? dotIdx : sel.length; + var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel; + elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag) + : document.createElement(tag); + if (hash < dot) elm.id = sel.slice(hash + 1, dot); + if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\./g, ' '); + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + elm.appendChild(createElm(children[i])); + } + } else if (is.primitive(vnode.text)) { + elm.appendChild(document.createTextNode(vnode.text)); + } + for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode); + i = vnode.data.hook; // Reuse variable + if (isDef(i)) { + if (i.create) i.create(emptyNode, vnode); + if (i.insert) insertedVnodeQueue.push(vnode); + } + } else { + elm = vnode.elm = document.createTextNode(vnode.text); + } + return vnode.elm; + } + + function addVnodes(parentElm, before, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + parentElm.insertBefore(createElm(vnodes[startIdx]), before); + } + } + + function invokeDestroyHook(vnode) { + var i = vnode.data, j; + if (isDef(i)) { + if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode); + for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode); + if (isDef(i = vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); + } + } + } + } + + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var i, listeners, rm, ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm, listeners); + for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm); + if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) { + i(ch, rm); + } else { + rm(); + } + } else { // Text node + parentElm.removeChild(ch.elm); + } + } + } + } + + function updateChildren(parentElm, oldCh, newCh) { + var oldStartIdx = 0, newStartIdx = 0; + var oldEndIdx = oldCh.length - 1; + var oldStartVnode = oldCh[0]; + var oldEndVnode = oldCh[oldEndIdx]; + var newEndIdx = newCh.length - 1; + var newStartVnode = newCh[0]; + var newEndVnode = newCh[newEndIdx]; + var oldKeyToIdx, idxInOld, elmToMove, before; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } else if (sameVnode(oldStartVnode, newStartVnode)) { + patchVnode(oldStartVnode, newStartVnode); + oldStartVnode = oldCh[++oldStartIdx]; + newStartVnode = newCh[++newStartIdx]; + } else if (sameVnode(oldEndVnode, newEndVnode)) { + patchVnode(oldEndVnode, newEndVnode); + oldEndVnode = oldCh[--oldEndIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right + patchVnode(oldStartVnode, newEndVnode); + parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left + patchVnode(oldEndVnode, newStartVnode); + parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { // New element + parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + patchVnode(elmToMove, newStartVnode); + oldCh[idxInOld] = undefined; + parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } + } + } + if (oldStartIdx > oldEndIdx) { + before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx); + } else if (newStartIdx > newEndIdx) { + removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); + } + } + + function patchVnode(oldVnode, vnode) { + var i, hook; + if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) { + i(oldVnode, vnode); + } + if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i; + if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i; + var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children; + if (oldVnode === vnode) return; + if (isDef(vnode.data)) { + for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode); + i = vnode.data.hook; + if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode); + } + if (isUndef(vnode.text)) { + if (isDef(oldCh) && isDef(ch)) { + if (oldCh !== ch) updateChildren(elm, oldCh, ch); + } else if (isDef(ch)) { + addVnodes(elm, null, ch, 0, ch.length - 1); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + } else if (oldVnode.text !== vnode.text) { + elm.textContent = vnode.text; + } + if (isDef(hook) && isDef(i = hook.postpatch)) { + i(oldVnode, vnode); + } + return vnode; + } + + return function(oldVnode, vnode) { + var i; + insertedVnodeQueue = []; + for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i](); + if (oldVnode instanceof Element) { + if (oldVnode.parentElement !== null) { + createElm(vnode); + oldVnode.parentElement.replaceChild(vnode.elm, oldVnode); + } else { + oldVnode = emptyNodeAt(oldVnode); + patchVnode(oldVnode, vnode); + } + } else { + patchVnode(oldVnode, vnode); + } + for (i = 0; i < insertedVnodeQueue.length; ++i) { + insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]); + } + insertedVnodeQueue = undefined; + for (i = 0; i < cbs.post.length; ++i) cbs.post[i](); + return vnode; + }; +} + +module.exports = {init: init}; + +},{"./is":69,"./vnode":76}],76:[function(require,module,exports){ +module.exports = function(sel, data, children, text, elm) { + var key = data === undefined ? undefined : data.key; + return {sel: sel, data: data, children: children, + text: text, elm: elm, key: key}; +}; + +},{}],77:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Wraps a function of any arity (including nullary) in a function that accepts exactly `n` + * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function, + * functions produced by `arity` will pass all provided arguments to the wrapped function. + * + * @func + * @memberOf R + * @sig (Number, (* -> *)) -> (* -> *) + * @category Function + * @param {Number} n The desired arity of the returned function. + * @param {Function} fn The function to wrap. + * @return {Function} A new function wrapping `fn`. The new function is + * guaranteed to be of arity `n`. + * @deprecated since v0.15.0 + * @example + * + * var takesTwoArgs = function(a, b) { + * return [a, b]; + * }; + * takesTwoArgs.length; //=> 2 + * takesTwoArgs(1, 2); //=> [1, 2] + * + * var takesOneArg = R.arity(1, takesTwoArgs); + * takesOneArg.length; //=> 1 + * // All arguments are passed through to the wrapped function + * takesOneArg(1, 2); //=> [1, 2] + */ +module.exports = _curry2(function(n, fn) { + // jshint unused:vars + switch (n) { + case 0: return function() {return fn.apply(this, arguments);}; + case 1: return function(a0) {return fn.apply(this, arguments);}; + case 2: return function(a0, a1) {return fn.apply(this, arguments);}; + case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);}; + case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);}; + case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);}; + case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);}; + case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);}; + case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);}; + case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);}; + case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);}; + default: throw new Error('First argument to arity must be a non-negative integer no greater than ten'); + } +}); + +},{"./internal/_curry2":80}],78:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _curryN = require('./internal/_curryN'); +var arity = require('./arity'); + + +/** + * Returns a curried equivalent of the provided function, with the + * specified arity. The curried function has two unusual capabilities. + * First, its arguments needn't be provided one at a time. If `g` is + * `R.curryN(3, f)`, the following are equivalent: + * + * - `g(1)(2)(3)` + * - `g(1)(2, 3)` + * - `g(1, 2)(3)` + * - `g(1, 2, 3)` + * + * Secondly, the special placeholder value `R.__` may be used to specify + * "gaps", allowing partial application of any combination of arguments, + * regardless of their positions. If `g` is as above and `_` is `R.__`, + * the following are equivalent: + * + * - `g(1, 2, 3)` + * - `g(_, 2, 3)(1)` + * - `g(_, _, 3)(1)(2)` + * - `g(_, _, 3)(1, 2)` + * - `g(_, 2)(1)(3)` + * - `g(_, 2)(1, 3)` + * - `g(_, 2)(_, 3)(1)` + * + * @func + * @memberOf R + * @category Function + * @sig Number -> (* -> a) -> (* -> a) + * @param {Number} length The arity for the returned function. + * @param {Function} fn The function to curry. + * @return {Function} A new, curried function. + * @see R.curry + * @example + * + * var addFourNumbers = function() { + * return R.sum([].slice.call(arguments, 0, 4)); + * }; + * + * var curriedAddFourNumbers = R.curryN(4, addFourNumbers); + * var f = curriedAddFourNumbers(1, 2); + * var g = f(3); + * g(4); //=> 10 + */ +module.exports = _curry2(function curryN(length, fn) { + return arity(length, _curryN(length, [], fn)); +}); + +},{"./arity":77,"./internal/_curry2":80,"./internal/_curryN":81}],79:[function(require,module,exports){ +/** + * Optimized internal two-arity curry function. + * + * @private + * @category Function + * @param {Function} fn The function to curry. + * @return {Function} The curried function. + */ +module.exports = function _curry1(fn) { + return function f1(a) { + if (arguments.length === 0) { + return f1; + } else if (a != null && a['@@functional/placeholder'] === true) { + return f1; + } else { + return fn(a); + } + }; +}; + +},{}],80:[function(require,module,exports){ +arguments[4][31][0].apply(exports,arguments) +},{"./_curry1":79,"dup":31}],81:[function(require,module,exports){ +var arity = require('../arity'); + + +/** + * Internal curryN function. + * + * @private + * @category Function + * @param {Number} length The arity of the curried function. + * @return {array} An array of arguments received thus far. + * @param {Function} fn The function to curry. + */ +module.exports = function _curryN(length, received, fn) { + return function() { + var combined = []; + var argsIdx = 0; + var left = length; + var combinedIdx = 0; + while (combinedIdx < received.length || argsIdx < arguments.length) { + var result; + if (combinedIdx < received.length && + (received[combinedIdx] == null || + received[combinedIdx]['@@functional/placeholder'] !== true || + argsIdx >= arguments.length)) { + result = received[combinedIdx]; + } else { + result = arguments[argsIdx]; + argsIdx += 1; + } + combined[combinedIdx] = result; + if (result == null || result['@@functional/placeholder'] !== true) { + left -= 1; + } + combinedIdx += 1; + } + return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn)); + }; +}; + +},{"../arity":77}],82:[function(require,module,exports){ +var curryN = require('ramda/src/curryN'); + +function isString(s) { return typeof s === 'string'; } +function isNumber(n) { return typeof n === 'number'; } +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} +function isFunction(f) { return typeof f === 'function'; } +var isArray = Array.isArray || function(a) { return 'length' in a; }; + +var mapConstrToFn = curryN(2, function(group, constr) { + return constr === String ? isString + : constr === Number ? isNumber + : constr === Object ? isObject + : constr === Array ? isArray + : constr === Function ? isFunction + : constr === undefined ? group + : constr; +}); + +function Constructor(group, name, validators) { + validators = validators.map(mapConstrToFn(group)); + var constructor = curryN(validators.length, function() { + var val = [], v, validator; + for (var i = 0; i < arguments.length; ++i) { + v = arguments[i]; + validator = validators[i]; + if ((typeof validator === 'function' && validator(v)) || + (v !== undefined && v !== null && v.of === validator)) { + val[i] = arguments[i]; + } else { + throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name); + } + } + val.of = group; + val.name = name; + return val; + }); + return constructor; +} + +function rawCase(type, cases, action, arg) { + if (type !== action.of) throw new TypeError('wrong type passed to case'); + var name = action.name in cases ? action.name + : '_' in cases ? '_' + : undefined; + if (name === undefined) { + throw new Error('unhandled value passed to case'); + } else { + return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action); + } +} + +var typeCase = curryN(3, rawCase); +var caseOn = curryN(4, rawCase); + +function Type(desc) { + var obj = {}; + for (var key in desc) { + obj[key] = Constructor(obj, key, desc[key]); + } + obj.case = typeCase(obj); + obj.caseOn = caseOn(obj); + return obj; +} + +module.exports = Type; + +},{"ramda/src/curryN":78}]},{},[3]) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EACzC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC/B,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACvC;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;AC1E/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAC7B,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC9BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC,CAC1C;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,MAAM;IAChB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAC5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,YAAY,EAAE,CACd,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACtD,CAAC,CAAC,cAAc,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACtD,CAAC,CAAC,YAAY,EAAK,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACtD,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CACvD,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,SAAS,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACnD,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACtD,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAE,CAAC,GAElC,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAC1C;CACH;;AAED,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;AAChC,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC5K9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const listItemView = (item, i) => {\n    const subview = upload.view(\n                      { progress: { height: 20, weight: 200 } },\n                      item\n                    );\n    return h('li', {}, [subview]);\n  }\n\n  return (\n    h('ul', {}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\nconst uploader = require('./uploader');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': 'stop'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div.upload', [\n      h('div.title',     [ renderTitle(model)             ]),\n      h('div.progress',  [ renderProgress(model,progress) ]),\n      h('div.status',    [ renderStatus(model)            ]),\n      h('div.abort',     [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  const titlespan = h('span.title', {}, model.title);\n  const sizespan = h('span.size', {}, '' + size(model));  // TODO readable bytesize\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ titlespan, sizespan ])\n\n      :  h('span', {}, [ titlespan, sizespan]) \n  );\n}\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: visible(abortable, model),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index a7e0747..ede9347 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -11,10 +11,12 @@ const uploader = require('./uploader'); const sync = (s) => [s, []]; +const isFileList = (x) => !(undefined === x.length) + // action const Action = Type({ - Create: [Function, Array], + Create: [Function, isFileList], Result: [Number, uploader.Result] }); @@ -38,8 +40,8 @@ const update = Action.caseOn({ NotFound: finish('Error'), Error: finish('Error'), Abort: finish('Abort'), - Progress: (p,abort) => { - return adjust(upload.update(upload.Action.Progress(p,abort)), i, model); + Progress: (abort,p) => { + return adjust(upload.update(upload.Action.Progress(abort,p)), i, model); } }, result) ); @@ -58,11 +60,11 @@ const nextIndex = (model) => model.length; const view = (model) => { const listItemView = (item, i) => { - const view = upload.view( - { progress: { height: 20, weight: 200 } }, - item - ); - return h('li', {}, view); + const subview = upload.view( + { progress: { height: 20, weight: 200 } }, + item + ); + return h('li', {}, [subview]); } return ( diff --git a/examples/file-uploader/js/main.js b/examples/file-uploader/js/main.js index c2d5396..4073fef 100644 --- a/examples/file-uploader/js/main.js +++ b/examples/file-uploader/js/main.js @@ -5,11 +5,12 @@ const patch = require('snabbdom').init([ require('snabbdom/modules/class'), require('snabbdom/modules/style'), require('snabbdom/modules/props'), + require('snabbdom/modules/attributes'), require('snabbdom/modules/eventlisteners') ]); const app = require('./app'); -const uploader = require('./uploader); +const uploader = require('./uploader'); let state = app.init(), asyncActions, vnode diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js index e846c5c..7489866 100644 --- a/examples/file-uploader/js/upload.js +++ b/examples/file-uploader/js/upload.js @@ -3,7 +3,7 @@ const Type = require('union-type'); const map = require('ramda/src/map') , reduce = require('ramda/src/reduce') , curry = require('ramda/src/curry') - , find = require('ramda/src/find') + , contains = require('ramda/src/contains') , always = require('ramda/src/always') , merge = require('ramda/src/merge') , evolve = require('ramda/src/evolve') @@ -61,7 +61,7 @@ const aborted = (model) => { } const abortable = (model) => { - return !!model.abort && !!find(model.status, ['uploading']); + return !!model.abort && contains(model.status, ['uploading']); } const hasProgressData = (x) => { @@ -79,14 +79,14 @@ const percentProgress = (p) => { // NOTE: no async tasks initiated, so all updates simply return changed state const Action = Type({ - Progress: [hasProgressData, Function], + Progress: [Function, hasProgressData], Uploaded: [], Error: [], Abort: [] }); const update = Action.caseOn({ - Progress: ({loaded,total},abort,model) => { + Progress: (abort,{loaded,total},model) => { return evolve({ status: always(loaded < total ? 'uploading' : 'processing'), progress: always({loaded, total}), abort: always(abort) @@ -104,11 +104,11 @@ const view = curry( ({progress},model) => { progress = merge({width: 200, height: 20}, progress || {}); return ( - h('div.upload', {}, [ - h('div.title', {} [ renderTitle(model) ]), - h('div.progress', {}, [ renderProgress(model,progress) ]), - h('div.status', {}, [ renderStatus(model) ]), - h('div.abort', {}, [ renderAbort(model) ]) + h('div.upload', [ + h('div.title', [ renderTitle(model) ]), + h('div.progress', [ renderProgress(model,progress) ]), + h('div.status', [ renderStatus(model) ]), + h('div.abort', [ renderAbort(model) ]) ]) ); @@ -119,9 +119,9 @@ function renderTitle(model){ const sizespan = h('span.size', {}, '' + size(model)); // TODO readable bytesize return ( model.url - ? h('a', { attr: {'href': model.url, - 'target': '_blank' - } + ? h('a', { attrs: {'href': model.url, + 'target': '_blank' + } }, [ titlespan, sizespan ]) : h('span', {}, [ titlespan, sizespan]) @@ -134,19 +134,20 @@ function renderProgress(model,specs){ y1: 0, y2: specs.height }; const rect = ( - s('rect.bar', { attr: { height: specs.height, - width: barwidth - } - } ) + s('rect', { attrs: { height: specs.height, + width: barwidth, + class: 'bar' + } + }) ); const line = ( - s('line.end', { attr: linespecs } ) + s('line', { attrs: merge(linespecs, {class: 'end'}) } ) ); return ( - s('svg', {attr: specs}, [ - s('g', {}, (barwidth > 0) && uploading(model) ? [rect,line] : []) + s('svg', {attrs: specs}, [ + s('g', {}, (barwidth > 0) ? [rect,line] : []) ]) ); diff --git a/examples/file-uploader/js/uploader.js b/examples/file-uploader/js/uploader.js index 4bd588a..53f8d19 100644 --- a/examples/file-uploader/js/uploader.js +++ b/examples/file-uploader/js/uploader.js @@ -3,6 +3,7 @@ const compose = require('ramda/src/compose') , __ = require('ramda/src/__') , curry = require('ramda/src/curry') + , always = require('ramda/src/always') ; const Type = require('union-type'); const Future = require('ramda-fantasy/src/Future'); @@ -15,24 +16,23 @@ const Result = Type({ Error: [Object], Abort: [Object], Unknown: [Object], - Progress: [Object, Function] + Progress: [Function, Object] }); const upload = curry( (headers, url, files) => { headers = headers || {}; - progress = progress || identity; return new Future( (rej,res) => { const xhr = new XMLHttpRequest(); const getxhr = always(xhr); const abort = xhr.abort.bind(xhr); xhr.addEventListener("load", compose(res, deriveResult, getxhr), false); - xhr.addEventListener("abort", compose(res, Result.Abort, getxhr), false); - xhr.addEventListener("error", compose(res, Result.Error, getxhr), false); + xhr.addEventListener("abort", compose(res, Result.Abort(xhr) ), false); + xhr.addEventListener("error", compose(res, Result.Error(xhr) ), false); xhr.upload.addEventListener("progress", - compose(res, Result.Progress(__,abort)), false); + compose(res, Result.Progress(abort)), false); xhr.open("post", url, true); for (k in headers){ @@ -50,7 +50,7 @@ function deriveResult(xhr){ xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : xhr.status >= 500 ? Result.Error : Result.Unknown - ); + )(xhr); } function formdata(files){ diff --git a/examples/file-uploader/package.json b/examples/file-uploader/package.json index c9457b6..c27a0d7 100644 --- a/examples/file-uploader/package.json +++ b/examples/file-uploader/package.json @@ -4,15 +4,16 @@ "description": "File uploader example", "main": "index.js", "scripts": { - "pretest": "browserify js/test.js -t /usr/lib/node_modules/babelify --outfile js/test_build.js", + "pretest": "browserify js/test.js --debug -t /usr/lib/node_modules/babelify --outfile js/test_build.js", "test": "node js/test_build.js | ./node_modules/tap-spec/bin/cmd.js", - "build": "browserify js/main.js -t /usr/lib/node_modules/babelify --outfile js/build.js" + "build": "browserify js/main.js --debug -t /usr/lib/node_modules/babelify --outfile js/build.js" }, "author": "Eric Gjertsen", "license": "MIT", "devDependencies": { "tape": "^4.2.0", - "tap-spec": "^4.1.0" + "tap-spec": "^4.1.0", + "multiparty": "^4.1.0" }, "dependencies": { "ramda": "^0.17.0", diff --git a/examples/file-uploader/server.js b/examples/file-uploader/server.js new file mode 100644 index 0000000..42644dd --- /dev/null +++ b/examples/file-uploader/server.js @@ -0,0 +1,100 @@ +'use strict'; + +var http = require('http'); +var fs = require('fs'); +var path = require('path'); +var url = require('url'); + +var multipart = require('multiparty'); + +var UPLOADDIR = 'uploads'; +var PORT = process.argv[2] || 8080; + +createServer(function(req,res){ + + if (req.url == '/upload' && req.method == 'POST'){ + var form = new multipart.Form(); + + form.on('part', function(part){ + if (!part.filename) return; + + try { + var fsOut = path.join(__dirname, UPLOADDIR, part.filename); + var out = fs.createWriteStream(fsOut); + part.pipe(out); + console.log('-> ' + fsOut); + } catch (e) { + console.error('-X ' + fsOut); + console.error("Upload error: " + e.message); + respond(500, e.message, res); + } + + }); + + form.on('error', function(){ + respond(400, 'Unable to parse as multipart', res); + }); + + form.on('close', function(){ + respond(200, 'OK', res); + }); + + form.parse(req); + + return; + } + + // otherwise, static file serving + + if (req.method == 'GET') { + var requestUrl = url.parse(req.url); + var fsPath = path.join( __dirname, requestUrl.pathname); + + fs.exists(fsPath, function(exists) { + try { + if(exists) { + console.log('<- ' + fsPath); + res.writeHead(200) + fs.createReadStream(fsPath).pipe(res); + } else { + console.error("X- " + fsPath); + respond(404, "Not Found", res); + } + } catch (e) { + res.end(); + } + }); + + } else { + respond(404, "Not Found", res); + } + + + function errhand(e){ + respond(500, e.message, res); + }; + +}).listen(PORT); + + + +function createServer(app){ + return http.createServer( wrap(app) ); +} + +function wrap(app){ + return function(req,res){ + try { + app(req,res); + } + catch (e) { + respond(500, e.message + "\n" + e.stack, res) + } + } +} + +function respond(status, msg, res){ + res.writeHead(status, {'content-type': 'text/plain'}); + res.write(msg); + res.end(); +} From 13b888e5f85815a4bf511c02198c8aedb7894200 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Fri, 28 Aug 2015 15:33:10 -0400 Subject: [PATCH 3/9] file-uploader example: style upload view --- examples/file-uploader/index.html | 59 +++++++++++++++++++++++++++++ examples/file-uploader/js/build.js | 6 +-- examples/file-uploader/js/list.js | 2 +- examples/file-uploader/js/upload.js | 2 +- 4 files changed, 64 insertions(+), 5 deletions(-) diff --git a/examples/file-uploader/index.html b/examples/file-uploader/index.html index 92a6b43..972b3a6 100644 --- a/examples/file-uploader/index.html +++ b/examples/file-uploader/index.html @@ -5,6 +5,65 @@ File Uploader diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index 69d29ba..a4cb352 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -143,7 +143,7 @@ var nextIndex = function nextIndex(model) { var view = function view(model) { var listItemView = function listItemView(item, i) { - var subview = upload.view({ progress: { height: 20, weight: 200 } }, item); + var subview = upload.view({ progress: { height: 20, width: 200 } }, item); return h('li', {}, [subview]); }; @@ -323,7 +323,7 @@ var view = curry(function (_ref3, model) { progress = merge({ width: 200, height: 20 }, progress || {}); - return h('div.upload', [h('div.title', [renderTitle(model)]), h('div.progress', [renderProgress(model, progress)]), h('div.status', [renderStatus(model)]), h('div.abort', [renderAbort(model)])]); + return h('div', { attrs: { 'class': 'upload ' + model.status } }, [h('div.title', [renderTitle(model)]), h('div.progress', [renderProgress(model, progress)]), h('div.status', [renderStatus(model)]), h('div.abort', [renderAbort(model)])]); }); function renderTitle(model) { @@ -10479,4 +10479,4 @@ function Type(desc) { module.exports = Type; },{"ramda/src/curryN":78}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EACzC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC/B,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACvC;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;AC1E/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAC7B,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC9BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC,CAC1C;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,MAAM;IAChB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAC5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,YAAY,EAAE,CACd,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACtD,CAAC,CAAC,cAAc,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACtD,CAAC,CAAC,YAAY,EAAK,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACtD,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CACvD,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,SAAS,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACnD,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACtD,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAE,CAAC,GAElC,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAC1C;CACH;;AAED,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;AAChC,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC5K9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7OA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const listItemView = (item, i) => {\n    const subview = upload.view(\n                      { progress: { height: 20, weight: 200 } },\n                      item\n                    );\n    return h('li', {}, [subview]);\n  }\n\n  return (\n    h('ul', {}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\nconst uploader = require('./uploader');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': 'stop'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div.upload', [\n      h('div.title',     [ renderTitle(model)             ]),\n      h('div.progress',  [ renderProgress(model,progress) ]),\n      h('div.status',    [ renderStatus(model)            ]),\n      h('div.abort',     [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  const titlespan = h('span.title', {}, model.title);\n  const sizespan = h('span.size', {}, '' + size(model));  // TODO readable bytesize\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ titlespan, sizespan ])\n\n      :  h('span', {}, [ titlespan, sizespan]) \n  );\n}\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: visible(abortable, model),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC/B,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACvC;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;AC1E/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAC7B,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC9BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC,CAC1C;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,MAAM;IAChB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAC5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAG,CAC1D,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACtD,CAAC,CAAC,cAAc,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACtD,CAAC,CAAC,YAAY,EAAK,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACtD,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CACvD,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,SAAS,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACnD,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACtD,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAE,CAAC,GAElC,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAC1C;CACH;;AAED,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;AAChC,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC5K9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7OA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const listItemView = (item, i) => {\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {}, [subview]);\n  }\n\n  return (\n    h('ul', {}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\nconst uploader = require('./uploader');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': 'stop'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status } },  [\n      h('div.title',     [ renderTitle(model)             ]),\n      h('div.progress',  [ renderProgress(model,progress) ]),\n      h('div.status',    [ renderStatus(model)            ]),\n      h('div.abort',     [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  const titlespan = h('span.title', {}, model.title);\n  const sizespan = h('span.size', {}, '' + size(model));  // TODO readable bytesize\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ titlespan, sizespan ])\n\n      :  h('span', {}, [ titlespan, sizespan]) \n  );\n}\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: visible(abortable, model),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index ede9347..20d464f 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -61,7 +61,7 @@ const view = (model) => { const listItemView = (item, i) => { const subview = upload.view( - { progress: { height: 20, weight: 200 } }, + { progress: { height: 20, width: 200 } }, item ); return h('li', {}, [subview]); diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js index 7489866..12c1e2a 100644 --- a/examples/file-uploader/js/upload.js +++ b/examples/file-uploader/js/upload.js @@ -104,7 +104,7 @@ const view = curry( ({progress},model) => { progress = merge({width: 200, height: 20}, progress || {}); return ( - h('div.upload', [ + h('div', { attrs: { 'class': 'upload ' + model.status } }, [ h('div.title', [ renderTitle(model) ]), h('div.progress', [ renderProgress(model,progress) ]), h('div.status', [ renderStatus(model) ]), From 49a54a39398b9ff1d7fdcea04713a0f0a23e86b5 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Fri, 28 Aug 2015 18:41:11 -0400 Subject: [PATCH 4/9] file-uploader example: move structural styling to js --- examples/file-uploader/index.html | 29 +--- examples/file-uploader/js/build.js | 221 +++++++++++++++++----------- examples/file-uploader/js/list.js | 11 +- examples/file-uploader/js/main.js | 1 - examples/file-uploader/js/upload.js | 32 ++-- examples/file-uploader/server.js | 4 + 6 files changed, 171 insertions(+), 127 deletions(-) diff --git a/examples/file-uploader/index.html b/examples/file-uploader/index.html index 972b3a6..037d9b5 100644 --- a/examples/file-uploader/index.html +++ b/examples/file-uploader/index.html @@ -13,19 +13,7 @@ margin: 1%; } - .uploading li { - list-style: none; - } - - .uploading ul { - list-style: none; - -webkit-margin-before: 0; - -webkit-margin-after: 0; - -webkit-padding-start: 0; - } - .upload { - display: inline-block; padding: 0.5rem; margin: 0.5rem; border: 1px solid lightgrey; @@ -37,31 +25,26 @@ } .upload.error { - color: pink; + color: red; } .upload.abort { color: lightgrey; } - .upload > div { - display: inline-block; - vertical-align: top; - margin-right: 0.25rem; - } - .upload > .status { - vertical-align: middle; text-transform: uppercase; font-size: 0.7em; + transform: translateY(30%); } - .upload > .progress .bar { + .upload > .progress rect.bar { fill: steelblue; } - .upload > .title > * > span { - margin-right: 0.25rem; + .upload > .progress line.end { + stroke: lightgrey; + stroke-width: 1; } diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index a4cb352..14f23b6 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -72,7 +72,7 @@ var preventDefault = invoker(0, 'preventDefault'); module.exports = { init: init, update: update, Action: Action, view: view }; -},{"./list":2,"./uploader":6,"ramda/src/T":9,"ramda/src/assoc":14,"ramda/src/compose":16,"ramda/src/curry":18,"ramda/src/invoker":53,"ramda/src/map":57,"snabbdom/h":68,"union-type":82}],2:[function(require,module,exports){ +},{"./list":2,"./uploader":6,"ramda/src/T":9,"ramda/src/assoc":14,"ramda/src/compose":16,"ramda/src/curry":18,"ramda/src/invoker":54,"ramda/src/map":58,"snabbdom/h":69,"union-type":83}],2:[function(require,module,exports){ 'use strict'; var Type = require('union-type'); @@ -142,17 +142,24 @@ var nextIndex = function nextIndex(model) { var view = function view(model) { + var style = { 'list-style': 'none', + '-webkit-margin-before': 0, + '-webkit-margin-after': 0, + '-webkit-padding-start': 0 + }; + var listItemView = function listItemView(item, i) { + var substyle = {}; var subview = upload.view({ progress: { height: 20, width: 200 } }, item); - return h('li', {}, [subview]); + return h('li', { style: substyle }, [subview]); }; - return h('ul', {}, model.map(listItemView)); + return h('ul', { style: style }, model.map(listItemView)); }; module.exports = { init: init, update: update, Action: Action, view: view }; -},{"./upload":5,"./uploader":6,"ramda/src/T":9,"ramda/src/adjust":11,"ramda/src/append":13,"ramda/src/curry":18,"snabbdom/h":68,"union-type":82}],3:[function(require,module,exports){ +},{"./upload":5,"./uploader":6,"ramda/src/T":9,"ramda/src/adjust":11,"ramda/src/append":13,"ramda/src/curry":18,"snabbdom/h":69,"union-type":83}],3:[function(require,module,exports){ /* globals: document, window */ 'use strict'; @@ -163,7 +170,6 @@ var map = require('ramda/src/map'); var patch = require('snabbdom').init([require('snabbdom/modules/class'), require('snabbdom/modules/style'), require('snabbdom/modules/props'), require('snabbdom/modules/attributes'), require('snabbdom/modules/eventlisteners')]); var app = require('./app'); -var uploader = require('./uploader'); var state = app.init(), asyncActions = undefined, @@ -195,7 +201,7 @@ window.addEventListener('DOMContentLoaded', function () { render(); }); -},{"./app":1,"./uploader":6,"ramda/src/map":57,"snabbdom":75,"snabbdom/modules/attributes":70,"snabbdom/modules/class":71,"snabbdom/modules/eventlisteners":72,"snabbdom/modules/props":73,"snabbdom/modules/style":74}],4:[function(require,module,exports){ +},{"./app":1,"ramda/src/map":58,"snabbdom":76,"snabbdom/modules/attributes":71,"snabbdom/modules/class":72,"snabbdom/modules/eventlisteners":73,"snabbdom/modules/props":74,"snabbdom/modules/style":75}],4:[function(require,module,exports){ 'use strict'; var h = require('snabbdom/h'); @@ -206,7 +212,7 @@ module.exports = function svg() { return vnode; }; -},{"snabbdom/h":68}],5:[function(require,module,exports){ +},{"snabbdom/h":69}],5:[function(require,module,exports){ 'use strict'; var Type = require('union-type'); @@ -217,7 +223,8 @@ var map = require('ramda/src/map'), contains = require('ramda/src/contains'), always = require('ramda/src/always'), merge = require('ramda/src/merge'), - evolve = require('ramda/src/evolve'); + evolve = require('ramda/src/evolve'), + dissoc = require('ramda/src/dissoc'); var h = require('snabbdom/h'), s = require('./svg'); @@ -258,7 +265,7 @@ var statusLabel = function statusLabel(model) { var actionLabel = function actionLabel(action) { return ({ - 'abort': 'stop' + 'abort': '×' })[action] || null; }; @@ -321,18 +328,23 @@ var update = Action.caseOn({ var view = curry(function (_ref3, model) { var progress = _ref3.progress; + var style = { 'display': 'inline-block' }; + + var substyle = { 'display': 'inline-block', + 'vertical-align': 'top', + 'margin-right': '1rem' + }; + progress = merge({ width: 200, height: 20 }, progress || {}); - return h('div', { attrs: { 'class': 'upload ' + model.status } }, [h('div.title', [renderTitle(model)]), h('div.progress', [renderProgress(model, progress)]), h('div.status', [renderStatus(model)]), h('div.abort', [renderAbort(model)])]); + return h('div', { attrs: { 'class': 'upload ' + model.status }, style: style }, [h('div.title', { style: substyle }, [renderTitle(model)]), h('div.size', { style: substyle }, ['' + size(model)]), h('div.progress', { style: substyle }, [renderProgress(model, progress)]), h('div.status', { style: substyle }, [renderStatus(model)]), h('div.abort', { style: dissoc('margin-right', substyle) }, [renderAbort(model)])]); }); function renderTitle(model) { - var titlespan = h('span.title', {}, model.title); - var sizespan = h('span.size', {}, '' + size(model)); // TODO readable bytesize return model.url ? h('a', { attrs: { 'href': model.url, 'target': '_blank' } - }, [titlespan, sizespan]) : h('span', {}, [titlespan, sizespan]); + }, [model.title]) : h('span', {}, [model.title]); } function renderProgress(model, specs) { @@ -358,7 +370,7 @@ function renderStatus(model) { function renderAbort(model) { var label = actionLabel('abort'); - return h('a', { style: visible(abortable, model), + return h('a', { style: merge(visible(abortable, model), { cursor: 'pointer' }), on: { click: model.abort } }, label); } @@ -368,7 +380,7 @@ function visible(pred, model) { module.exports = { init: init, Action: Action, update: update, view: view }; -},{"./svg":4,"ramda/src/always":12,"ramda/src/contains":17,"ramda/src/curry":18,"ramda/src/evolve":21,"ramda/src/map":57,"ramda/src/merge":58,"ramda/src/reduce":60,"snabbdom/h":68,"union-type":82}],6:[function(require,module,exports){ +},{"./svg":4,"ramda/src/always":12,"ramda/src/contains":17,"ramda/src/curry":18,"ramda/src/dissoc":20,"ramda/src/evolve":22,"ramda/src/map":58,"ramda/src/merge":59,"ramda/src/reduce":61,"snabbdom/h":69,"union-type":83}],6:[function(require,module,exports){ /* globals XMLHttpRequest, FormData */ 'use strict'; @@ -427,7 +439,7 @@ function formdata(files) { }return data; } -},{"ramda-fantasy/src/Future":7,"ramda/src/__":10,"ramda/src/always":12,"ramda/src/compose":16,"ramda/src/curry":18,"union-type":82}],7:[function(require,module,exports){ +},{"ramda-fantasy/src/Future":7,"ramda/src/__":10,"ramda/src/always":12,"ramda/src/compose":16,"ramda/src/curry":18,"union-type":83}],7:[function(require,module,exports){ var R = require('ramda'); // `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success) @@ -8140,7 +8152,7 @@ module.exports = _curry3(function adjust(fn, idx, list) { return _list; }); -},{"./internal/_concat":28,"./internal/_curry3":32}],12:[function(require,module,exports){ +},{"./internal/_concat":29,"./internal/_curry3":33}],12:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); @@ -8168,7 +8180,7 @@ module.exports = _curry1(function always(val) { }; }); -},{"./internal/_curry1":30}],13:[function(require,module,exports){ +},{"./internal/_curry1":31}],13:[function(require,module,exports){ var _concat = require('./internal/_concat'); var _curry2 = require('./internal/_curry2'); @@ -8196,7 +8208,7 @@ module.exports = _curry2(function append(el, list) { return _concat(list, [el]); }); -},{"./internal/_concat":28,"./internal/_curry2":31}],14:[function(require,module,exports){ +},{"./internal/_concat":29,"./internal/_curry2":32}],14:[function(require,module,exports){ var _curry3 = require('./internal/_curry3'); @@ -8228,7 +8240,7 @@ module.exports = _curry3(function assoc(prop, val, obj) { return result; }); -},{"./internal/_curry3":32}],15:[function(require,module,exports){ +},{"./internal/_curry3":33}],15:[function(require,module,exports){ var _arity = require('./internal/_arity'); var _curry2 = require('./internal/_curry2'); @@ -8254,7 +8266,7 @@ module.exports = _curry2(function bind(fn, thisObj) { }); }); -},{"./internal/_arity":24,"./internal/_curry2":31}],16:[function(require,module,exports){ +},{"./internal/_arity":25,"./internal/_curry2":32}],16:[function(require,module,exports){ var pipe = require('./pipe'); var reverse = require('./reverse'); @@ -8283,7 +8295,7 @@ module.exports = function compose() { return pipe.apply(this, reverse(arguments)); }; -},{"./pipe":59,"./reverse":62}],17:[function(require,module,exports){ +},{"./pipe":60,"./reverse":63}],17:[function(require,module,exports){ var _contains = require('./internal/_contains'); var _curry2 = require('./internal/_curry2'); @@ -8308,7 +8320,7 @@ var _curry2 = require('./internal/_curry2'); */ module.exports = _curry2(_contains); -},{"./internal/_contains":29,"./internal/_curry2":31}],18:[function(require,module,exports){ +},{"./internal/_contains":30,"./internal/_curry2":32}],18:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var curryN = require('./curryN'); @@ -8359,7 +8371,7 @@ module.exports = _curry1(function curry(fn) { return curryN(fn.length, fn); }); -},{"./curryN":19,"./internal/_curry1":30}],19:[function(require,module,exports){ +},{"./curryN":19,"./internal/_curry1":31}],19:[function(require,module,exports){ var _arity = require('./internal/_arity'); var _curry1 = require('./internal/_curry1'); var _curry2 = require('./internal/_curry2'); @@ -8416,7 +8428,36 @@ module.exports = _curry2(function curryN(length, fn) { return _arity(length, _curryN(length, [], fn)); }); -},{"./internal/_arity":24,"./internal/_curry1":30,"./internal/_curry2":31,"./internal/_curryN":33}],20:[function(require,module,exports){ +},{"./internal/_arity":25,"./internal/_curry1":31,"./internal/_curry2":32,"./internal/_curryN":34}],20:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns a new object that does not contain a `prop` property. + * + * @func + * @memberOf R + * @category Object + * @sig String -> {k: v} -> {k: v} + * @param {String} prop the name of the property to dissociate + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original but without the specified property + * @see R.assoc + * @example + * + * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} + */ +module.exports = _curry2(function dissoc(prop, obj) { + var result = {}; + for (var p in obj) { + if (p !== prop) { + result[p] = obj[p]; + } + } + return result; +}); + +},{"./internal/_curry2":32}],21:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _equals = require('./internal/_equals'); var _hasMethod = require('./internal/_hasMethod'); @@ -8449,7 +8490,7 @@ module.exports = _curry2(function equals(a, b) { _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []); }); -},{"./internal/_curry2":31,"./internal/_equals":35,"./internal/_hasMethod":38}],21:[function(require,module,exports){ +},{"./internal/_curry2":32,"./internal/_equals":36,"./internal/_hasMethod":39}],22:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -8490,7 +8531,7 @@ module.exports = _curry2(function evolve(transformations, object) { return result; }); -},{"./internal/_curry2":31}],22:[function(require,module,exports){ +},{"./internal/_curry2":32}],23:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _dispatchable = require('./internal/_dispatchable'); var _filter = require('./internal/_filter'); @@ -8525,7 +8566,7 @@ var _xfilter = require('./internal/_xfilter'); */ module.exports = _curry2(_dispatchable('filter', _xfilter, _filter)); -},{"./internal/_curry2":31,"./internal/_dispatchable":34,"./internal/_filter":36,"./internal/_xfilter":50}],23:[function(require,module,exports){ +},{"./internal/_curry2":32,"./internal/_dispatchable":35,"./internal/_filter":37,"./internal/_xfilter":51}],24:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -8562,7 +8603,7 @@ module.exports = _curry2(function identical(a, b) { } }); -},{"./internal/_curry2":31}],24:[function(require,module,exports){ +},{"./internal/_curry2":32}],25:[function(require,module,exports){ module.exports = function _arity(n, fn) { // jshint unused:vars switch (n) { @@ -8581,7 +8622,7 @@ module.exports = function _arity(n, fn) { } }; -},{}],25:[function(require,module,exports){ +},{}],26:[function(require,module,exports){ var _isArray = require('./_isArray'); var _slice = require('./_slice'); @@ -8609,7 +8650,7 @@ module.exports = function _checkForMethod(methodname, fn) { }; }; -},{"./_isArray":40,"./_slice":46}],26:[function(require,module,exports){ +},{"./_isArray":41,"./_slice":47}],27:[function(require,module,exports){ module.exports = function _cloneRegExp(pattern) { return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + @@ -8618,14 +8659,14 @@ module.exports = function _cloneRegExp(pattern) { (pattern.unicode ? 'u' : '')); }; -},{}],27:[function(require,module,exports){ +},{}],28:[function(require,module,exports){ module.exports = function _complement(f) { return function() { return !f.apply(this, arguments); }; }; -},{}],28:[function(require,module,exports){ +},{}],29:[function(require,module,exports){ /** * Private `concat` function to merge two array-like objects. * @@ -8658,7 +8699,7 @@ module.exports = function _concat(set1, set2) { return result; }; -},{}],29:[function(require,module,exports){ +},{}],30:[function(require,module,exports){ var _indexOf = require('./_indexOf'); @@ -8666,7 +8707,7 @@ module.exports = function _contains(a, list) { return _indexOf(list, a, 0) >= 0; }; -},{"./_indexOf":39}],30:[function(require,module,exports){ +},{"./_indexOf":40}],31:[function(require,module,exports){ /** * Optimized internal two-arity curry function. * @@ -8687,7 +8728,7 @@ module.exports = function _curry1(fn) { }; }; -},{}],31:[function(require,module,exports){ +},{}],32:[function(require,module,exports){ var _curry1 = require('./_curry1'); @@ -8721,7 +8762,7 @@ module.exports = function _curry2(fn) { }; }; -},{"./_curry1":30}],32:[function(require,module,exports){ +},{"./_curry1":31}],33:[function(require,module,exports){ var _curry1 = require('./_curry1'); var _curry2 = require('./_curry2'); @@ -8777,7 +8818,7 @@ module.exports = function _curry3(fn) { }; }; -},{"./_curry1":30,"./_curry2":31}],33:[function(require,module,exports){ +},{"./_curry1":31,"./_curry2":32}],34:[function(require,module,exports){ var _arity = require('./_arity'); @@ -8817,7 +8858,7 @@ module.exports = function _curryN(length, received, fn) { }; }; -},{"./_arity":24}],34:[function(require,module,exports){ +},{"./_arity":25}],35:[function(require,module,exports){ var _isArray = require('./_isArray'); var _isTransformer = require('./_isTransformer'); var _slice = require('./_slice'); @@ -8858,7 +8899,7 @@ module.exports = function _dispatchable(methodname, xf, fn) { }; }; -},{"./_isArray":40,"./_isTransformer":41,"./_slice":46}],35:[function(require,module,exports){ +},{"./_isArray":41,"./_isTransformer":42,"./_slice":47}],36:[function(require,module,exports){ var _has = require('./_has'); var identical = require('../identical'); var keys = require('../keys'); @@ -8927,7 +8968,7 @@ module.exports = function _equals(a, b, stackA, stackB) { return false; }; -},{"../identical":23,"../keys":56,"../type":67,"./_has":37}],36:[function(require,module,exports){ +},{"../identical":24,"../keys":57,"../type":68,"./_has":38}],37:[function(require,module,exports){ module.exports = function _filter(fn, list) { var idx = 0, len = list.length, result = []; while (idx < len) { @@ -8939,12 +8980,12 @@ module.exports = function _filter(fn, list) { return result; }; -},{}],37:[function(require,module,exports){ +},{}],38:[function(require,module,exports){ module.exports = function _has(prop, obj) { return Object.prototype.hasOwnProperty.call(obj, prop); }; -},{}],38:[function(require,module,exports){ +},{}],39:[function(require,module,exports){ var _isArray = require('./_isArray'); @@ -8969,7 +9010,7 @@ module.exports = function _hasMethod(methodName, obj) { return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function'; }; -},{"./_isArray":40}],39:[function(require,module,exports){ +},{"./_isArray":41}],40:[function(require,module,exports){ var equals = require('../equals'); @@ -8984,7 +9025,7 @@ module.exports = function _indexOf(list, item, from) { return -1; }; -},{"../equals":20}],40:[function(require,module,exports){ +},{"../equals":21}],41:[function(require,module,exports){ /** * Tests whether or not an object is an array. * @@ -9003,12 +9044,12 @@ module.exports = Array.isArray || function _isArray(val) { Object.prototype.toString.call(val) === '[object Array]'); }; -},{}],41:[function(require,module,exports){ +},{}],42:[function(require,module,exports){ module.exports = function _isTransformer(obj) { return typeof obj['@@transducer/step'] === 'function'; }; -},{}],42:[function(require,module,exports){ +},{}],43:[function(require,module,exports){ module.exports = function _map(fn, list) { var idx = 0, len = list.length, result = Array(len); while (idx < len) { @@ -9018,19 +9059,19 @@ module.exports = function _map(fn, list) { return result; }; -},{}],43:[function(require,module,exports){ +},{}],44:[function(require,module,exports){ module.exports = function _pipe(f, g) { return function() { return g.call(this, f.apply(this, arguments)); }; }; -},{}],44:[function(require,module,exports){ +},{}],45:[function(require,module,exports){ module.exports = function _quote(s) { return '"' + s.replace(/"/g, '\\"') + '"'; }; -},{}],45:[function(require,module,exports){ +},{}],46:[function(require,module,exports){ var _xwrap = require('./_xwrap'); var bind = require('../bind'); var isArrayLike = require('../isArrayLike'); @@ -9088,7 +9129,7 @@ module.exports = (function() { }; })(); -},{"../bind":15,"../isArrayLike":55,"./_xwrap":52}],46:[function(require,module,exports){ +},{"../bind":15,"../isArrayLike":56,"./_xwrap":53}],47:[function(require,module,exports){ /** * An optimized, private array `slice` implementation. * @@ -9122,7 +9163,7 @@ module.exports = function _slice(args, from, to) { } }; -},{}],47:[function(require,module,exports){ +},{}],48:[function(require,module,exports){ /** * Polyfill from . */ @@ -9146,7 +9187,7 @@ module.exports = (function() { }; }()); -},{}],48:[function(require,module,exports){ +},{}],49:[function(require,module,exports){ var _contains = require('./_contains'); var _map = require('./_map'); var _quote = require('./_quote'); @@ -9192,7 +9233,7 @@ module.exports = function _toString(x, seen) { } }; -},{"../keys":56,"../reject":61,"../test":65,"./_contains":29,"./_map":42,"./_quote":44,"./_toISOString":47}],49:[function(require,module,exports){ +},{"../keys":57,"../reject":62,"../test":66,"./_contains":30,"./_map":43,"./_quote":45,"./_toISOString":48}],50:[function(require,module,exports){ module.exports = { init: function() { return this.xf['@@transducer/init'](); @@ -9202,7 +9243,7 @@ module.exports = { } }; -},{}],50:[function(require,module,exports){ +},{}],51:[function(require,module,exports){ var _curry2 = require('./_curry2'); var _xfBase = require('./_xfBase'); @@ -9221,7 +9262,7 @@ module.exports = (function() { return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); }); })(); -},{"./_curry2":31,"./_xfBase":49}],51:[function(require,module,exports){ +},{"./_curry2":32,"./_xfBase":50}],52:[function(require,module,exports){ var _curry2 = require('./_curry2'); var _xfBase = require('./_xfBase'); @@ -9240,7 +9281,7 @@ module.exports = (function() { return _curry2(function _xmap(f, xf) { return new XMap(f, xf); }); })(); -},{"./_curry2":31,"./_xfBase":49}],52:[function(require,module,exports){ +},{"./_curry2":32,"./_xfBase":50}],53:[function(require,module,exports){ module.exports = (function() { function XWrap(fn) { this.f = fn; @@ -9256,7 +9297,7 @@ module.exports = (function() { return function _xwrap(fn) { return new XWrap(fn); }; }()); -},{}],53:[function(require,module,exports){ +},{}],54:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _slice = require('./internal/_slice'); var curryN = require('./curryN'); @@ -9296,7 +9337,7 @@ module.exports = _curry2(function invoker(arity, method) { }); }); -},{"./curryN":19,"./internal/_curry2":31,"./internal/_slice":46,"./is":54,"./toString":66}],54:[function(require,module,exports){ +},{"./curryN":19,"./internal/_curry2":32,"./internal/_slice":47,"./is":55,"./toString":67}],55:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -9326,7 +9367,7 @@ module.exports = _curry2(function is(Ctor, val) { return val != null && val.constructor === Ctor || val instanceof Ctor; }); -},{"./internal/_curry2":31}],55:[function(require,module,exports){ +},{"./internal/_curry2":32}],56:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _isArray = require('./internal/_isArray'); @@ -9362,7 +9403,7 @@ module.exports = _curry1(function isArrayLike(x) { return false; }); -},{"./internal/_curry1":30,"./internal/_isArray":40}],56:[function(require,module,exports){ +},{"./internal/_curry1":31,"./internal/_isArray":41}],57:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _has = require('./internal/_has'); @@ -9428,7 +9469,7 @@ module.exports = (function() { }); }()); -},{"./internal/_curry1":30,"./internal/_has":37}],57:[function(require,module,exports){ +},{"./internal/_curry1":31,"./internal/_has":38}],58:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _dispatchable = require('./internal/_dispatchable'); var _map = require('./internal/_map'); @@ -9463,7 +9504,7 @@ var _xmap = require('./internal/_xmap'); */ module.exports = _curry2(_dispatchable('map', _xmap, _map)); -},{"./internal/_curry2":31,"./internal/_dispatchable":34,"./internal/_map":42,"./internal/_xmap":51}],58:[function(require,module,exports){ +},{"./internal/_curry2":32,"./internal/_dispatchable":35,"./internal/_map":43,"./internal/_xmap":52}],59:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var keys = require('./keys'); @@ -9504,7 +9545,7 @@ module.exports = _curry2(function merge(a, b) { return result; }); -},{"./internal/_curry2":31,"./keys":56}],59:[function(require,module,exports){ +},{"./internal/_curry2":32,"./keys":57}],60:[function(require,module,exports){ var _pipe = require('./internal/_pipe'); var curryN = require('./curryN'); var reduce = require('./reduce'); @@ -9538,7 +9579,7 @@ module.exports = function pipe() { reduce(_pipe, arguments[0], tail(arguments))); }; -},{"./curryN":19,"./internal/_pipe":43,"./reduce":60,"./tail":64}],60:[function(require,module,exports){ +},{"./curryN":19,"./internal/_pipe":44,"./reduce":61,"./tail":65}],61:[function(require,module,exports){ var _curry3 = require('./internal/_curry3'); var _reduce = require('./internal/_reduce'); @@ -9576,7 +9617,7 @@ var _reduce = require('./internal/_reduce'); */ module.exports = _curry3(_reduce); -},{"./internal/_curry3":32,"./internal/_reduce":45}],61:[function(require,module,exports){ +},{"./internal/_curry3":33,"./internal/_reduce":46}],62:[function(require,module,exports){ var _complement = require('./internal/_complement'); var _curry2 = require('./internal/_curry2'); var filter = require('./filter'); @@ -9608,7 +9649,7 @@ module.exports = _curry2(function reject(fn, list) { return filter(_complement(fn), list); }); -},{"./filter":22,"./internal/_complement":27,"./internal/_curry2":31}],62:[function(require,module,exports){ +},{"./filter":23,"./internal/_complement":28,"./internal/_curry2":32}],63:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _slice = require('./internal/_slice'); @@ -9634,7 +9675,7 @@ module.exports = _curry1(function reverse(list) { return _slice(list).reverse(); }); -},{"./internal/_curry1":30,"./internal/_slice":46}],63:[function(require,module,exports){ +},{"./internal/_curry1":31,"./internal/_slice":47}],64:[function(require,module,exports){ var _checkForMethod = require('./internal/_checkForMethod'); var _curry3 = require('./internal/_curry3'); @@ -9664,7 +9705,7 @@ module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIn return Array.prototype.slice.call(list, fromIndex, toIndex); })); -},{"./internal/_checkForMethod":25,"./internal/_curry3":32}],64:[function(require,module,exports){ +},{"./internal/_checkForMethod":26,"./internal/_curry3":33}],65:[function(require,module,exports){ var _checkForMethod = require('./internal/_checkForMethod'); var slice = require('./slice'); @@ -9695,7 +9736,7 @@ var slice = require('./slice'); */ module.exports = _checkForMethod('tail', slice(1, Infinity)); -},{"./internal/_checkForMethod":25,"./slice":63}],65:[function(require,module,exports){ +},{"./internal/_checkForMethod":26,"./slice":64}],66:[function(require,module,exports){ var _cloneRegExp = require('./internal/_cloneRegExp'); var _curry2 = require('./internal/_curry2'); @@ -9720,7 +9761,7 @@ module.exports = _curry2(function test(pattern, str) { return _cloneRegExp(pattern).test(str); }); -},{"./internal/_cloneRegExp":26,"./internal/_curry2":31}],66:[function(require,module,exports){ +},{"./internal/_cloneRegExp":27,"./internal/_curry2":32}],67:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _toString = require('./internal/_toString'); @@ -9762,7 +9803,7 @@ var _toString = require('./internal/_toString'); */ module.exports = _curry1(function toString(val) { return _toString(val, []); }); -},{"./internal/_curry1":30,"./internal/_toString":48}],67:[function(require,module,exports){ +},{"./internal/_curry1":31,"./internal/_toString":49}],68:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); @@ -9793,7 +9834,7 @@ module.exports = _curry1(function type(val) { Object.prototype.toString.call(val).slice(8, -1); }); -},{"./internal/_curry1":30}],68:[function(require,module,exports){ +},{"./internal/_curry1":31}],69:[function(require,module,exports){ var VNode = require('./vnode'); var is = require('./is'); @@ -9816,13 +9857,13 @@ module.exports = function h(sel, b, c) { return VNode(sel, data, children, text, undefined); }; -},{"./is":69,"./vnode":76}],69:[function(require,module,exports){ +},{"./is":70,"./vnode":77}],70:[function(require,module,exports){ module.exports = { array: Array.isArray, primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; }, }; -},{}],70:[function(require,module,exports){ +},{}],71:[function(require,module,exports){ var booleanAttrs = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "compact", "controls", "declare", "default", "defaultchecked", "defaultmuted", "defaultselected", "defer", "disabled", "draggable", "enabled", "formnovalidate", "hidden", "indeterminate", "inert", "ismap", "itemscope", "loop", "multiple", @@ -9863,7 +9904,7 @@ function updateAttrs(oldVnode, vnode) { module.exports = {create: updateAttrs, update: updateAttrs}; -},{}],71:[function(require,module,exports){ +},{}],72:[function(require,module,exports){ function updateClass(oldVnode, vnode) { var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class || {}, @@ -9878,7 +9919,7 @@ function updateClass(oldVnode, vnode) { module.exports = {create: updateClass, update: updateClass}; -},{}],72:[function(require,module,exports){ +},{}],73:[function(require,module,exports){ var is = require('../is'); function arrInvoker(arr) { @@ -9921,7 +9962,7 @@ function updateEventListeners(oldVnode, vnode) { module.exports = {create: updateEventListeners, update: updateEventListeners}; -},{"../is":69}],73:[function(require,module,exports){ +},{"../is":70}],74:[function(require,module,exports){ function updateProps(oldVnode, vnode) { var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props || {}, props = vnode.data.props || {}; @@ -9936,7 +9977,7 @@ function updateProps(oldVnode, vnode) { module.exports = {create: updateProps, update: updateProps}; -},{}],74:[function(require,module,exports){ +},{}],75:[function(require,module,exports){ var raf = requestAnimationFrame || setTimeout; var nextFrame = function(fn) { raf(function() { raf(fn); }); }; @@ -9997,7 +10038,7 @@ function applyRemoveStyle(vnode, rm) { module.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle}; -},{}],75:[function(require,module,exports){ +},{}],76:[function(require,module,exports){ // jshint newcap: false /* global require, module, document, Element */ 'use strict'; @@ -10236,14 +10277,14 @@ function init(modules) { module.exports = {init: init}; -},{"./is":69,"./vnode":76}],76:[function(require,module,exports){ +},{"./is":70,"./vnode":77}],77:[function(require,module,exports){ module.exports = function(sel, data, children, text, elm) { var key = data === undefined ? undefined : data.key; return {sel: sel, data: data, children: children, text: text, elm: elm, key: key}; }; -},{}],77:[function(require,module,exports){ +},{}],78:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -10292,7 +10333,7 @@ module.exports = _curry2(function(n, fn) { } }); -},{"./internal/_curry2":80}],78:[function(require,module,exports){ +},{"./internal/_curry2":81}],79:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _curryN = require('./internal/_curryN'); var arity = require('./arity'); @@ -10345,7 +10386,7 @@ module.exports = _curry2(function curryN(length, fn) { return arity(length, _curryN(length, [], fn)); }); -},{"./arity":77,"./internal/_curry2":80,"./internal/_curryN":81}],79:[function(require,module,exports){ +},{"./arity":78,"./internal/_curry2":81,"./internal/_curryN":82}],80:[function(require,module,exports){ /** * Optimized internal two-arity curry function. * @@ -10366,9 +10407,9 @@ module.exports = function _curry1(fn) { }; }; -},{}],80:[function(require,module,exports){ -arguments[4][31][0].apply(exports,arguments) -},{"./_curry1":79,"dup":31}],81:[function(require,module,exports){ +},{}],81:[function(require,module,exports){ +arguments[4][32][0].apply(exports,arguments) +},{"./_curry1":80,"dup":32}],82:[function(require,module,exports){ var arity = require('../arity'); @@ -10408,7 +10449,7 @@ module.exports = function _curryN(length, received, fn) { }; }; -},{"../arity":77}],82:[function(require,module,exports){ +},{"../arity":78}],83:[function(require,module,exports){ var curryN = require('ramda/src/curryN'); function isString(s) { return typeof s === 'string'; } @@ -10478,5 +10519,5 @@ function Type(desc) { module.exports = Type; -},{"ramda/src/curryN":78}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC/B,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACvC;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;AC1E/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAC7B,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC9BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC,CAC1C;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,MAAM;IAChB,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAC5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAG,CAC1D,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACtD,CAAC,CAAC,cAAc,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACtD,CAAC,CAAC,YAAY,EAAK,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACtD,CAAC,CAAC,WAAW,EAAM,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CACvD,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,SAAS,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACnD,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACtD,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAE,CAAC,GAElC,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAC1C;CACH;;AAED,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;AAChC,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC5K9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7OA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const listItemView = (item, i) => {\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {}, [subview]);\n  }\n\n  return (\n    h('ul', {}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\nconst uploader = require('./uploader');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': 'stop'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status } },  [\n      h('div.title',     [ renderTitle(model)             ]),\n      h('div.progress',  [ renderProgress(model,progress) ]),\n      h('div.status',    [ renderStatus(model)            ]),\n      h('div.abort',     [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  const titlespan = h('span.title', {}, model.title);\n  const sizespan = h('span.size', {}, '' + size(model));  // TODO readable bytesize\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ titlespan, sizespan ])\n\n      :  h('span', {}, [ titlespan, sizespan]) \n  );\n}\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: visible(abortable, model),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +},{"ramda/src/curryN":79}]},{},[3]) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACjF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7OA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index 20d464f..396c559 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -59,16 +59,23 @@ const nextIndex = (model) => model.length; const view = (model) => { + const style = {'list-style': 'none', + '-webkit-margin-before': 0, + '-webkit-margin-after': 0, + '-webkit-padding-start': 0 + }; + const listItemView = (item, i) => { + const substyle = { }; const subview = upload.view( { progress: { height: 20, width: 200 } }, item ); - return h('li', {}, [subview]); + return h('li', {style: substyle}, [subview]); } return ( - h('ul', {}, model.map( listItemView ) ) + h('ul', {style}, model.map( listItemView ) ) ); }; diff --git a/examples/file-uploader/js/main.js b/examples/file-uploader/js/main.js index 4073fef..88c37cf 100644 --- a/examples/file-uploader/js/main.js +++ b/examples/file-uploader/js/main.js @@ -10,7 +10,6 @@ const patch = require('snabbdom').init([ ]); const app = require('./app'); -const uploader = require('./uploader'); let state = app.init(), asyncActions, vnode diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js index 12c1e2a..6928bf8 100644 --- a/examples/file-uploader/js/upload.js +++ b/examples/file-uploader/js/upload.js @@ -7,6 +7,7 @@ const map = require('ramda/src/map') , always = require('ramda/src/always') , merge = require('ramda/src/merge') , evolve = require('ramda/src/evolve') + , dissoc = require('ramda/src/dissoc') ; const h = require('snabbdom/h') @@ -45,7 +46,7 @@ const statusLabel = (model) => { const actionLabel = (action) => { return { - 'abort': 'stop' + 'abort': '×' }[action] || null ; } @@ -101,33 +102,42 @@ const update = Action.caseOn({ // view const view = curry( ({progress},model) => { + + const style = { 'display': 'inline-block' }; + + const substyle = { 'display': 'inline-block', + 'vertical-align': 'top', + 'margin-right': '1rem' + }; + progress = merge({width: 200, height: 20}, progress || {}); return ( - h('div', { attrs: { 'class': 'upload ' + model.status } }, [ - h('div.title', [ renderTitle(model) ]), - h('div.progress', [ renderProgress(model,progress) ]), - h('div.status', [ renderStatus(model) ]), - h('div.abort', [ renderAbort(model) ]) + h('div', { attrs: { 'class': 'upload ' + model.status }, style }, [ + h('div.title', {style: substyle}, [ renderTitle(model) ]), + h('div.size', {style: substyle}, [ ''+size(model) ]), + h('div.progress', {style: substyle}, [ renderProgress(model,progress) ]), + h('div.status', {style: substyle}, [ renderStatus(model) ]), + h('div.abort', {style: dissoc('margin-right',substyle)}, + [ renderAbort(model) ]) ]) ); }); function renderTitle(model){ - const titlespan = h('span.title', {}, model.title); - const sizespan = h('span.size', {}, '' + size(model)); // TODO readable bytesize return ( model.url ? h('a', { attrs: {'href': model.url, 'target': '_blank' } - }, [ titlespan, sizespan ]) + }, [ model.title ]) - : h('span', {}, [ titlespan, sizespan]) + : h('span', {}, [ model.title ]) ); } + function renderProgress(model,specs){ const barwidth = percentProgress(model.progress) * specs.width; const linespecs = { x1: specs.width, x2: specs.width, @@ -161,7 +171,7 @@ function renderStatus(model){ function renderAbort(model){ const label = actionLabel('abort'); - return h('a', { style: visible(abortable, model), + return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}), on: { click: model.abort } }, label ); diff --git a/examples/file-uploader/server.js b/examples/file-uploader/server.js index 42644dd..0076128 100644 --- a/examples/file-uploader/server.js +++ b/examples/file-uploader/server.js @@ -12,6 +12,10 @@ var PORT = process.argv[2] || 8080; createServer(function(req,res){ + req.on('abort', function(){ + respond(400, 'Error receiving', res); + }); + if (req.url == '/upload' && req.method == 'POST'){ var form = new multipart.Form(); From 0a9e6fb60fee71fcb3c91b42e134a5e15b992f35 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Fri, 28 Aug 2015 22:07:11 -0400 Subject: [PATCH 5/9] file-uploader example: add README --- examples/file-uploader/README.md | 86 ++++++++++++++++++++++++++++++ examples/file-uploader/index.html | 1 + examples/file-uploader/js/build.js | 4 +- examples/file-uploader/js/list.js | 4 +- 4 files changed, 93 insertions(+), 2 deletions(-) create mode 100644 examples/file-uploader/README.md diff --git a/examples/file-uploader/README.md b/examples/file-uploader/README.md new file mode 100644 index 0000000..75c33e4 --- /dev/null +++ b/examples/file-uploader/README.md @@ -0,0 +1,86 @@ +# File Uploader + +This example is a browser-based file-upload component, i.e. it renders a list +of chosen files, shows their upload progress, and allows users to cancel +uploads. + +Similar to the [zip-code-futures][zip] example, it demonstrates a way to do +asynchronous side effects in a controlled way. The top-level update function +(in `main.js`) was copied from that example. It features a convention for making +synchronous and asynchronous updates together which is very similar to Elm's +`effects`. You can read more about this in the [Elm architecture tutorial][elm]. + +It also features routing of nested updates, both synchronous (which 'bubble up' +the component tree in the familiar way, based on user events) and asynchronous +(which are constructed via future chains of actions to 'dive down' the component +tree, based on server responses). + +The uploader wraps XmlHttpRequest in a [ramda-fantasy][rf] Future, which +repeatedly resolves on XHR progress events. + + +## How to build it + +Install the dependencies. + +``` +npm install +``` + +Then build the code with + +``` +npm run build +``` + +Run the tests + +``` +npm run test +``` + + +## How to use it + +Create an uploads folder, if it doesn't already exist: + +``` +mkdir -p uploads +``` + +Start the test server + +``` +node server.js 8080 +``` + +Then open your browser to `http://localhost:8080/index.html`, and choose some +files to upload. + + +## Other notes + +- The example is intended to be a step towards a realistic stand-alone + file uploader, i.e. a 'widget' or reusable component. So `main` and `app` + give a picture of how you would integrate it into a real app. Comments + welcome on the app interface to the 'widget' (the `list` and `uploader`), + I am sure it could be improved. + +- 'Structural' styling is done via javacript, while app-specific styles can be + applied via CSS. + +- The XHR `abort` method is not handled in a pure way. This seems impossible, + at least using the Future interface. So there is a bit of a 'wormhole' + exposing this method back to the app and into the model, where it can be + hooked up to a click handler. Other suggestions welcome. + +- The tests include a simple dummy uploader for running unit tests independent + of XHR and the browser, an example of how easy it is to test using this + architecture. + + + +[zip]: https://github.com/paldepind/functional-frontend-architecture/tree/master/examples/zip-codes-future +[elm]: https://github.com/evancz/elm-architecture-tutorial#example-5-random-gif-viewer +[rf]: https://github.com/ramda/ramda-fantasy + diff --git a/examples/file-uploader/index.html b/examples/file-uploader/index.html index 037d9b5..98b5998 100644 --- a/examples/file-uploader/index.html +++ b/examples/file-uploader/index.html @@ -50,6 +50,7 @@ +

File Uploader example

diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index 14f23b6..2eb7225 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -89,6 +89,8 @@ var sync = function sync(s) { return [s, []]; }; +// note: prefer to check if iterable, +// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser? var isFileList = function isFileList(x) { return !(undefined === x.length); }; @@ -10520,4 +10522,4 @@ function Type(desc) { module.exports = Type; },{"ramda/src/curryN":79}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;AAE5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACjF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\nconst isFileList = (x) => !(undefined === x.length)\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACnF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => !(undefined === x.length) \n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index 396c559..38218cf 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -11,7 +11,9 @@ const uploader = require('./uploader'); const sync = (s) => [s, []]; -const isFileList = (x) => !(undefined === x.length) +// note: prefer to check if iterable, +// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser? +const isFileList = (x) => !(undefined === x.length) // action From 74973cf2e597b37345d7e15ddb0924796c43c971 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Fri, 28 Aug 2015 23:10:12 -0400 Subject: [PATCH 6/9] file-uploader example: fix abort bugs on server and client --- examples/file-uploader/js/build.js | 6 +++--- examples/file-uploader/js/uploader.js | 6 +++--- examples/file-uploader/server.js | 11 ++++++++++- 3 files changed, 16 insertions(+), 7 deletions(-) diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index 2eb7225..97cca0c 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -415,8 +415,8 @@ var upload = curry(function (headers, url, files) { var getxhr = always(xhr); var abort = xhr.abort.bind(xhr); xhr.addEventListener('load', compose(res, deriveResult, getxhr), false); - xhr.addEventListener('abort', compose(res, Result.Abort(xhr)), false); - xhr.addEventListener('error', compose(res, Result.Error(xhr)), false); + xhr.addEventListener('abort', compose(res, Result.Abort, getxhr), false); + xhr.addEventListener('error', compose(res, Result.Error, getxhr), false); xhr.upload.addEventListener('progress', compose(res, Result.Progress(abort)), false); @@ -10522,4 +10522,4 @@ function Type(desc) { module.exports = Type; },{"ramda/src/curryN":79}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACnF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;AACvE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAE,EAAE,KAAK,CAAC,CAAC;;AAEvE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => !(undefined === x.length) \n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr);\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort(xhr) ), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error(xhr) ), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACnF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => !(undefined === x.length) \n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/uploader.js b/examples/file-uploader/js/uploader.js index 53f8d19..043b8a4 100644 --- a/examples/file-uploader/js/uploader.js +++ b/examples/file-uploader/js/uploader.js @@ -26,10 +26,10 @@ const upload = curry( (headers, url, files) => { return new Future( (rej,res) => { const xhr = new XMLHttpRequest(); const getxhr = always(xhr); - const abort = xhr.abort.bind(xhr); + const abort = xhr.abort.bind(xhr) xhr.addEventListener("load", compose(res, deriveResult, getxhr), false); - xhr.addEventListener("abort", compose(res, Result.Abort(xhr) ), false); - xhr.addEventListener("error", compose(res, Result.Error(xhr) ), false); + xhr.addEventListener("abort", compose(res, Result.Abort, getxhr), false); + xhr.addEventListener("error", compose(res, Result.Error, getxhr), false); xhr.upload.addEventListener("progress", compose(res, Result.Progress(abort)), false); diff --git a/examples/file-uploader/server.js b/examples/file-uploader/server.js index 0076128..026662e 100644 --- a/examples/file-uploader/server.js +++ b/examples/file-uploader/server.js @@ -4,6 +4,7 @@ var http = require('http'); var fs = require('fs'); var path = require('path'); var url = require('url'); +var noop = function(){}; var multipart = require('multiparty'); @@ -13,6 +14,7 @@ var PORT = process.argv[2] || 8080; createServer(function(req,res){ req.on('abort', function(){ + res.on('error', noop); respond(400, 'Error receiving', res); }); @@ -21,9 +23,15 @@ createServer(function(req,res){ form.on('part', function(part){ if (!part.filename) return; + var fsOut = path.join(__dirname, UPLOADDIR, part.filename); + + part.on('error', function(){ + console.error('-| ' + fsOut); + res.on('error', noop); + respond(400, 'Error receiving', res); + }); try { - var fsOut = path.join(__dirname, UPLOADDIR, part.filename); var out = fs.createWriteStream(fsOut); part.pipe(out); console.log('-> ' + fsOut); @@ -36,6 +44,7 @@ createServer(function(req,res){ }); form.on('error', function(){ + res.on('error', noop); respond(400, 'Unable to parse as multipart', res); }); From 971edb8756b07f64c2344ae2763b8761f5fe9498 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Fri, 28 Aug 2015 23:21:10 -0400 Subject: [PATCH 7/9] file-uploader example: add to README --- examples/file-uploader/README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/examples/file-uploader/README.md b/examples/file-uploader/README.md index 75c33e4..141f4f4 100644 --- a/examples/file-uploader/README.md +++ b/examples/file-uploader/README.md @@ -15,7 +15,7 @@ the component tree in the familiar way, based on user events) and asynchronous (which are constructed via future chains of actions to 'dive down' the component tree, based on server responses). -The uploader wraps XmlHttpRequest in a [ramda-fantasy][rf] Future, which +The uploader wraps XMLHttpRequest in a [ramda-fantasy][rf] Future, which repeatedly resolves on XHR progress events. @@ -60,6 +60,9 @@ files to upload. ## Other notes +- The progress bar is rendered as SVG using @yelouafi 's [builder][svg] (not yet + part of snabbdom, but it works great!) + - The example is intended to be a step towards a realistic stand-alone file uploader, i.e. a 'widget' or reusable component. So `main` and `app` give a picture of how you would integrate it into a real app. Comments @@ -83,4 +86,5 @@ files to upload. [zip]: https://github.com/paldepind/functional-frontend-architecture/tree/master/examples/zip-codes-future [elm]: https://github.com/evancz/elm-architecture-tutorial#example-5-random-gif-viewer [rf]: https://github.com/ramda/ramda-fantasy +[svg]: https://github.com/paldepind/snabbdom/issues/4 From 6e99ca51ebb08682ea43c75ab9f814be0f0621ba Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Thu, 3 Sep 2015 12:38:40 -0400 Subject: [PATCH 8/9] file-uploader example: minor fixes suggested by @paldepind --- .gitignore | 1 + examples/file-uploader/js/app.js | 47 +- examples/file-uploader/js/build.js | 92 ++-- examples/file-uploader/js/list.js | 40 +- examples/file-uploader/js/main.js | 2 +- examples/file-uploader/js/test.js | 4 +- examples/file-uploader/js/test_build.js | 629 ++++++++++++++++-------- examples/file-uploader/js/upload.js | 50 +- examples/file-uploader/package.json | 7 +- 9 files changed, 569 insertions(+), 303 deletions(-) diff --git a/.gitignore b/.gitignore index 72af219..24bd5fc 100644 --- a/.gitignore +++ b/.gitignore @@ -25,5 +25,6 @@ build/Release # Dependency directory # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git node_modules +jspm_packages *.swp diff --git a/examples/file-uploader/js/app.js b/examples/file-uploader/js/app.js index 400a69f..f5f392f 100644 --- a/examples/file-uploader/js/app.js +++ b/examples/file-uploader/js/app.js @@ -13,6 +13,12 @@ const uploadList = require('./list'); const uploader = require('./uploader'); +// app constants + +const UPLOAD_URL = '/upload' +const UPLOAD_HEADERS = {} + + // action const listUpdate = (listAction,model) => { @@ -28,9 +34,9 @@ const Action = Type({ }); const update = Action.caseOn({ - Create: (up,files,model) => { - return listUpdate( uploadList.Action.Create(up,files), model ); - }, + Create: (up,files,model) => ( + listUpdate( uploadList.Action.Create(up,files), model ) + ), Route: listUpdate }); @@ -42,31 +48,32 @@ const init = () => { return { uploads: uploadList.init() }; } // view -const view = curry( ({url, headers, action$}, model) => { - - const up = uploader.upload(headers, url); - - const form = ( - h('form', {on: {submit: preventDefault} }, [ - h('input', - { props: {type: 'file', multiple: true}, - on: { - change: compose(action$, Action.Create(up), getTarget('files')) - } - } - ) - ] - ) - ); +const view = curry( ({action$}, model) => { + const up = uploader.upload(UPLOAD_HEADERS, UPLOAD_URL); + return ( h('div.uploading', {}, [ - form, + form(action$, up), uploadList.view(model.uploads) ]) ); }); +const form = (action$, up) => ( + h('form', {on: {submit: preventDefault} }, [ + h('input', + { props: {type: 'file', multiple: true}, + on: { + change: compose(action$, Action.Create(up), getTarget('files')) + } + } + ) + ] + ) +); + + const getTarget = curry( (key,e) => e.target[key] ); const preventDefault = invoker(0, 'preventDefault'); diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index 97cca0c..d9705f0 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -15,6 +15,11 @@ var h = require('snabbdom/h'); var uploadList = require('./list'); var uploader = require('./uploader'); +// app constants + +var UPLOAD_URL = '/upload'; +var UPLOAD_HEADERS = {}; + // action var listUpdate = function listUpdate(listAction, model) { @@ -50,20 +55,20 @@ var init = function init() { // view var view = curry(function (_ref, model) { - var url = _ref.url; - var headers = _ref.headers; var action$ = _ref.action$; - var up = uploader.upload(headers, url); + var up = uploader.upload(UPLOAD_HEADERS, UPLOAD_URL); + + return h('div.uploading', {}, [form(action$, up), uploadList.view(model.uploads)]); +}); - var form = h('form', { on: { submit: preventDefault } }, [h('input', { props: { type: 'file', multiple: true }, +var form = function form(action$, up) { + return h('form', { on: { submit: preventDefault } }, [h('input', { props: { type: 'file', multiple: true }, on: { change: compose(action$, Action.Create(up), getTarget('files')) } })]); - - return h('div.uploading', {}, [form, uploadList.view(model.uploads)]); -}); +}; var getTarget = curry(function (key, e) { return e.target[key]; @@ -85,14 +90,14 @@ var h = require('snabbdom/h'); var upload = require('./upload'); var uploader = require('./uploader'); -var sync = function sync(s) { +var noFx = function noFx(s) { return [s, []]; }; // note: prefer to check if iterable, // but FileList.prototype doesn't seem to have Symbol.iterator cross-browser? var isFileList = function isFileList(x) { - return !(undefined === x.length); + return x.length !== undefined; }; // action @@ -118,7 +123,7 @@ var update = Action.caseOn({ return adjust(upload.update(upload.Action[type]()), i, model); }; }; - return sync(uploader.Result['case']({ + return noFx(uploader.Result['case']({ OK: finish('Uploaded'), NotFound: finish('Error'), Error: finish('Error'), @@ -144,19 +149,16 @@ var nextIndex = function nextIndex(model) { var view = function view(model) { - var style = { 'list-style': 'none', - '-webkit-margin-before': 0, - '-webkit-margin-after': 0, - '-webkit-padding-start': 0 - }; + return h('ul', { style: style.ul }, model.map(listItemView)); +}; - var listItemView = function listItemView(item, i) { - var substyle = {}; - var subview = upload.view({ progress: { height: 20, width: 200 } }, item); - return h('li', { style: substyle }, [subview]); - }; +var listItemView = function listItemView(item, i) { + return h('li', { style: style.li }, [upload.view({ progress: { height: 20, width: 200 } }, item)]); +}; - return h('ul', { style: style }, model.map(listItemView)); +var style = { + ul: { 'list-style': 'none' }, + li: {} }; module.exports = { init: init, update: update, Action: Action, view: view }; @@ -178,7 +180,7 @@ var state = app.init(), vnode = undefined; var render = function render() { - vnode = patch(vnode, app.view({ action$: update, url: '/upload' }, state)); + vnode = patch(vnode, app.view({ action$: update }, state)); }; var update = function update(action) { @@ -301,7 +303,7 @@ var percentProgress = function percentProgress(p) { // action -// NOTE: no async tasks initiated, so all updates simply return changed state +// NOTE: no side-effects initiated, so all updates simply return changed state var Action = Type({ Progress: [Function, hasProgressData], @@ -330,26 +332,21 @@ var update = Action.caseOn({ var view = curry(function (_ref3, model) { var progress = _ref3.progress; - var style = { 'display': 'inline-block' }; - - var substyle = { 'display': 'inline-block', - 'vertical-align': 'top', - 'margin-right': '1rem' - }; - progress = merge({ width: 200, height: 20 }, progress || {}); - return h('div', { attrs: { 'class': 'upload ' + model.status }, style: style }, [h('div.title', { style: substyle }, [renderTitle(model)]), h('div.size', { style: substyle }, ['' + size(model)]), h('div.progress', { style: substyle }, [renderProgress(model, progress)]), h('div.status', { style: substyle }, [renderStatus(model)]), h('div.abort', { style: dissoc('margin-right', substyle) }, [renderAbort(model)])]); + return h('div', { attrs: { 'class': 'upload ' + model.status }, + style: style.upload + }, [h('div.title', { style: style.div }, [renderTitle(model)]), h('div.size', { style: style.div }, ['' + size(model)]), h('div.progress', { style: style.div }, [renderProgress(model, progress)]), h('div.status', { style: style.div }, [renderStatus(model)]), h('div.abort', { style: dissoc('margin-right', style.div) }, [renderAbort(model)])]); }); -function renderTitle(model) { +var renderTitle = function renderTitle(model) { return model.url ? h('a', { attrs: { 'href': model.url, 'target': '_blank' } }, [model.title]) : h('span', {}, [model.title]); -} +}; -function renderProgress(model, specs) { +var renderProgress = function renderProgress(model, specs) { var barwidth = percentProgress(model.progress) * specs.width; var linespecs = { x1: specs.width, x2: specs.width, y1: 0, y2: specs.height }; @@ -363,18 +360,29 @@ function renderProgress(model, specs) { var line = s('line', { attrs: merge(linespecs, { 'class': 'end' }) }); return s('svg', { attrs: specs }, [s('g', {}, barwidth > 0 ? [rect, line] : [])]); -} +}; -function renderStatus(model) { - var label = statusLabel(model); - return h('span', {}, label); -} +var renderStatus = function renderStatus(model) { + return h('span', {}, statusLabel(model)); +}; -function renderAbort(model) { +var renderAbort = function renderAbort(model) { var label = actionLabel('abort'); return h('a', { style: merge(visible(abortable, model), { cursor: 'pointer' }), on: { click: model.abort } }, label); -} +}; + +// view styles + +var style = { + upload: { 'display': 'inline-block' }, + div: { 'display': 'inline-block', + 'vertical-align': 'top', + 'margin-right': '1rem' + } +}; + +// view utils function visible(pred, model) { return { display: pred(model) ? null : 'none' }; @@ -10522,4 +10530,4 @@ function Type(desc) { module.exports = Type; },{"ramda/src/curryN":79}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,WAAO,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE,CAAC;GAChE;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAuB,EAAE,KAAK,EAAK;MAAlC,GAAG,GAAJ,IAAuB,CAAtB,GAAG;MAAE,OAAO,GAAb,IAAuB,CAAjB,OAAO;MAAE,OAAO,GAAtB,IAAuB,CAAR,OAAO;;AAEzC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;;AAEzC,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD,AACF,CAAC;;AAEF,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,EACJ,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACzE/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,EAAE,SAAS,KAAK,CAAC,CAAC,MAAM,CAAA,AAAC;CAAA,CAAA;;;;AAInD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,MAAM,KAAK,GAAG,EAAC,YAAY,EAAE,MAAM;AACpB,2BAAuB,EAAE,CAAC;AAC1B,0BAAsB,EAAE,CAAC;AACzB,2BAAuB,EAAE,CAAC;GAC1B,CAAC;;AAEhB,MAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,QAAM,QAAQ,GAAG,EAAG,CAAC;AACrB,QAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CAAC;AAClB,WAAO,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;GAC9C,CAAA;;AAED,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CAC5C;CAEH,CAAC;;AAGF,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACnF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1E,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,MAAM,KAAK,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC;;AAE5C,MAAM,QAAQ,GAAG,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB,CAAC;;AAEnB,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,KAAK,EAAL,KAAK,EAAE,EAAG,CACjE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EACzE,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EACzE,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EACzE,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EACzE,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAC,QAAQ,CAAC,EAAC,EACpB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC1E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH;;AAGD,SAAS,cAAc,CAAC,KAAK,EAAC,KAAK,EAAC;AAClC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH;;AAED,SAAS,YAAY,CAAC,KAAK,EAAC;AAC1B,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AACjC,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;CAC7B;;AAGD,SAAS,WAAW,CAAC,KAAK,EAAC;AACzB,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX;;AAED,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACtL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => {\n    return listUpdate( uploadList.Action.Create(up,files), model );\n  },\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({url, headers, action$}, model) => {\n  \n  const up = uploader.upload(headers, url);\n\n  const form = (\n    h('form', {on: {submit: preventDefault} }, [\n       h('input', \n         { props: {type: 'file', multiple: true},\n           on:   {\n             change: compose(action$, Action.Create(up), getTarget('files')) \n           }\n         }\n       )\n     ]\n    )\n  );\n\n  return (\n    h('div.uploading', {}, [\n      form,\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst sync = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => !(undefined === x.length) \n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return sync(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  const style = {'list-style': 'none',\n                 '-webkit-margin-before': 0,\n                 '-webkit-margin-after': 0,\n                 '-webkit-padding-start': 0\n                };\n\n  const listItemView = (item, i) => {\n    const substyle = { };\n    const subview = upload.view(\n                      { progress: { height: 20, width: 200 } },\n                      item\n                    );\n    return h('li', {style: substyle}, [subview]);\n  }\n\n  return (\n    h('ul', {style}, model.map( listItemView ) )\n  );\n\n};\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no async tasks initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  const style = { 'display': 'inline-block' };\n  \n  const substyle = { 'display': 'inline-block',\n                     'vertical-align': 'top',\n                     'margin-right': '1rem'\n                   };\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, style },  [\n      h('div.title',    {style: substyle},  [ renderTitle(model)             ]),\n      h('div.size',     {style: substyle},  [ ''+size(model)                 ]),\n      h('div.progress', {style: substyle},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: substyle},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right',substyle)},  \n                                            [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nfunction renderTitle(model){\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nfunction renderProgress(model,specs){\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nfunction renderStatus(model){\n  const label = statusLabel(model);\n  return h('span', {}, label);\n}\n\n\nfunction renderAbort(model){\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAS,CAAA;AAC5B,IAAM,cAAc,GAAG,EAAE,CAAA;;;;AAKzB,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK;WACrB,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE;GACxD;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAS,EAAE,KAAK,EAAK;MAApB,OAAO,GAAR,IAAS,CAAR,OAAO;;AAE3B,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;;AAEvD,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,EACjB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,OAAO,EAAE,EAAE;SACvB,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD;CACF,CAAC;;AAGF,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;AChF/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,CAAC,CAAC,MAAM,KAAK,SAAS;CAAA,CAAA;;;;AAIhD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACtD;CAEH,CAAC;;AAEF,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,CACzB,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CACF,CAAC,CACF;CACH,CAAA;;AAGD,IAAM,KAAK,GAAG;AACZ,IAAE,EAAE,EAAC,YAAY,EAAE,MAAM,EAAC;AAC1B,IAAE,EAAE,EAAG;CACR,CAAA;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACrF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1D,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE;AAC5C,SAAK,EAAE,KAAK,CAAC,MAAM;GACpB,EAAG,CACX,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EAC1E,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EAC1E,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EAC1E,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EAC1E,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC,EACrB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC3E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH,CAAA;;AAGD,IAAM,cAAc,GAAG,SAAjB,cAAc,CAAI,KAAK,EAAC,KAAK,EAAK;AACtC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH,CAAA;;AAED,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,KAAK,EAAK;AAC9B,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;CAC1C,CAAA;;AAGD,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX,CAAA;;;;AAKD,IAAM,KAAK,GAAG;AACZ,QAAM,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;AACrC,KAAG,EAAK,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB;CACV,CAAA;;;;AAKD,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC9L9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// app constants\n\nconst UPLOAD_URL = '/upload'\nconst UPLOAD_HEADERS = {}\n\n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => (\n    listUpdate( uploadList.Action.Create(up,files), model )\n  ),\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({action$}, model) => {\n\n  const up = uploader.upload(UPLOAD_HEADERS, UPLOAD_URL);\n  \n  return (\n    h('div.uploading', {}, [\n      form(action$, up),\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst form = (action$, up) => (\n  h('form', {on: {submit: preventDefault} }, [\n     h('input', \n       { props: {type: 'file', multiple: true},\n         on:   {\n           change: compose(action$, Action.Create(up), getTarget('files')) \n         }\n       }\n     )\n   ]\n  )\n);\n\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst noFx = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => x.length !== undefined\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return noFx(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  return (\n    h('ul', {style: style.ul}, model.map( listItemView ) )\n  );\n\n};\n\nconst listItemView = (item, i) => {\n  return (\n    h('li', {style: style.li}, [\n      upload.view(\n        { progress: { height: 20, width: 200 } },\n        item\n      )   \n    ])\n  );\n}\n\n\nconst style = {\n  ul: {'list-style': 'none'},\n  li: { }\n}\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no side-effects initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, \n               style: style.upload \n             },  [\n      h('div.title',    {style: style.div},  [ renderTitle(model)             ]),\n      h('div.size',     {style: style.div},  [ ''+size(model)                 ]),\n      h('div.progress', {style: style.div},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: style.div},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right', style.div)},   \n                                             [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nconst renderTitle = (model) => {\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nconst renderProgress = (model,specs) => {\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nconst renderStatus = (model) => {\n  return h('span', {}, statusLabel(model));\n}\n\n\nconst renderAbort = (model) => {\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\n\n// view styles \n\nconst style = { \n  upload: { 'display': 'inline-block' }, \n  div:    { 'display': 'inline-block',\n            'vertical-align': 'top',\n            'margin-right': '1rem'\n          }\n}\n\n\n// view utils\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index 38218cf..3c72af3 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -9,11 +9,11 @@ const h = require('snabbdom/h'); const upload = require('./upload'); const uploader = require('./uploader'); -const sync = (s) => [s, []]; +const noFx = (s) => [s, []]; // note: prefer to check if iterable, // but FileList.prototype doesn't seem to have Symbol.iterator cross-browser? -const isFileList = (x) => !(undefined === x.length) +const isFileList = (x) => x.length !== undefined // action @@ -36,7 +36,7 @@ const update = Action.caseOn({ const finish = (type) => () => { return adjust(upload.update(upload.Action[type]()), i, model); }; - return sync( + return noFx( uploader.Result.case({ OK: finish('Uploaded'), NotFound: finish('Error'), @@ -61,27 +61,29 @@ const nextIndex = (model) => model.length; const view = (model) => { - const style = {'list-style': 'none', - '-webkit-margin-before': 0, - '-webkit-margin-after': 0, - '-webkit-padding-start': 0 - }; - - const listItemView = (item, i) => { - const substyle = { }; - const subview = upload.view( - { progress: { height: 20, width: 200 } }, - item - ); - return h('li', {style: substyle}, [subview]); - } - return ( - h('ul', {style}, model.map( listItemView ) ) + h('ul', {style: style.ul}, model.map( listItemView ) ) ); }; +const listItemView = (item, i) => { + return ( + h('li', {style: style.li}, [ + upload.view( + { progress: { height: 20, width: 200 } }, + item + ) + ]) + ); +} + + +const style = { + ul: {'list-style': 'none'}, + li: { } +} + module.exports = { init, update, Action, view } diff --git a/examples/file-uploader/js/main.js b/examples/file-uploader/js/main.js index 88c37cf..07ff2f3 100644 --- a/examples/file-uploader/js/main.js +++ b/examples/file-uploader/js/main.js @@ -14,7 +14,7 @@ const app = require('./app'); let state = app.init(), asyncActions, vnode const render = () => { - vnode = patch(vnode, app.view({action$: update, url: '/upload'}, state)); + vnode = patch(vnode, app.view({action$: update}, state)); }; const update = (action) => { diff --git a/examples/file-uploader/js/test.js b/examples/file-uploader/js/test.js index e90c641..4ad9817 100644 --- a/examples/file-uploader/js/test.js +++ b/examples/file-uploader/js/test.js @@ -17,7 +17,7 @@ const noop = function(){} /******************************************************************************/ const progressUpload = (total, loaded, data) => { - return upload.update( upload.Action.Progress({total,loaded},noop), data ); + return upload.update( upload.Action.Progress(noop, {total,loaded}), data ); } const finishUpload = upload.update(upload.Action.Uploaded()); @@ -75,7 +75,7 @@ const dummyUploader = curry( (total, steps, abort, final, files) => { const progress = (loaded, delay) => { delay = delay + ( Math.random() * 2000 ); setTimeout( - () => res(uploader.Result.Progress({total,loaded},abort)), + () => res(uploader.Result.Progress(abort, {total,loaded})), delay ); return delay; diff --git a/examples/file-uploader/js/test_build.js b/examples/file-uploader/js/test_build.js index a198127..1df96ff 100644 --- a/examples/file-uploader/js/test_build.js +++ b/examples/file-uploader/js/test_build.js @@ -11,14 +11,20 @@ var h = require('snabbdom/h'); var upload = require('./upload'); var uploader = require('./uploader'); -var sync = function sync(s) { +var noFx = function noFx(s) { return [s, []]; }; +// note: prefer to check if iterable, +// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser? +var isFileList = function isFileList(x) { + return x.length !== undefined; +}; + // action var Action = Type({ - Create: [Function, Array], + Create: [Function, isFileList], Result: [Number, uploader.Result] }); @@ -38,13 +44,13 @@ var update = Action.caseOn({ return adjust(upload.update(upload.Action[type]()), i, model); }; }; - return sync(uploader.Result['case']({ + return noFx(uploader.Result['case']({ OK: finish('Uploaded'), NotFound: finish('Error'), Error: finish('Error'), Abort: finish('Abort'), - Progress: function Progress(p, abort) { - return adjust(upload.update(upload.Action.Progress(p, abort)), i, model); + Progress: function Progress(abort, p) { + return adjust(upload.update(upload.Action.Progress(abort, p)), i, model); } }, result)); } @@ -64,17 +70,21 @@ var nextIndex = function nextIndex(model) { var view = function view(model) { - var listItemView = function listItemView(item, i) { - var view = upload.view({ progress: { height: 20, weight: 200 } }, item); - return h('li', {}, view); - }; + return h('ul', { style: style.ul }, model.map(listItemView)); +}; + +var listItemView = function listItemView(item, i) { + return h('li', { style: style.li }, [upload.view({ progress: { height: 20, width: 200 } }, item)]); +}; - return h('ul', {}, model.map(listItemView)); +var style = { + ul: { 'list-style': 'none' }, + li: {} }; module.exports = { init: init, update: update, Action: Action, view: view }; -},{"./upload":4,"./uploader":5,"ramda/src/T":8,"ramda/src/adjust":10,"ramda/src/append":13,"ramda/src/curry":16,"snabbdom/h":51,"union-type":73}],2:[function(require,module,exports){ +},{"./upload":4,"./uploader":5,"ramda/src/T":8,"ramda/src/adjust":10,"ramda/src/append":13,"ramda/src/curry":17,"snabbdom/h":58,"union-type":80}],2:[function(require,module,exports){ 'use strict'; var h = require('snabbdom/h'); @@ -85,7 +95,7 @@ module.exports = function svg() { return vnode; }; -},{"snabbdom/h":51}],3:[function(require,module,exports){ +},{"snabbdom/h":58}],3:[function(require,module,exports){ 'use strict'; function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } } @@ -109,7 +119,7 @@ var noop = function noop() {}; /******************************************************************************/ var progressUpload = function progressUpload(total, loaded, data) { - return upload.update(upload.Action.Progress({ total: total, loaded: loaded }, noop), data); + return upload.update(upload.Action.Progress(noop, { total: total, loaded: loaded }), data); }; var finishUpload = upload.update(upload.Action.Uploaded()); @@ -157,7 +167,7 @@ var dummyUploader = curry(function (total, steps, abort, final, files) { var progress = function progress(loaded, delay) { delay = delay + Math.random() * 2000; setTimeout(function () { - return res(uploader.Result.Progress({ total: total, loaded: loaded }, abort)); + return res(uploader.Result.Progress(abort, { total: total, loaded: loaded })); }, delay); return delay; }; @@ -352,7 +362,7 @@ test('upload list component, add file list, result error', function (assert) { }, 2000); }); -},{"./list":1,"./upload":4,"./uploader":5,"ramda-fantasy/src/Future":6,"ramda/src/all":11,"ramda/src/compose":15,"ramda/src/curry":16,"ramda/src/map":43,"ramda/src/zip":50,"tape":54}],4:[function(require,module,exports){ +},{"./list":1,"./upload":4,"./uploader":5,"ramda-fantasy/src/Future":6,"ramda/src/all":11,"ramda/src/compose":15,"ramda/src/curry":17,"ramda/src/map":49,"ramda/src/zip":57,"tape":61}],4:[function(require,module,exports){ 'use strict'; var Type = require('union-type'); @@ -360,10 +370,11 @@ var Type = require('union-type'); var map = require('ramda/src/map'), reduce = require('ramda/src/reduce'), curry = require('ramda/src/curry'), - find = require('ramda/src/find'), + contains = require('ramda/src/contains'), always = require('ramda/src/always'), merge = require('ramda/src/merge'), - evolve = require('ramda/src/evolve'); + evolve = require('ramda/src/evolve'), + dissoc = require('ramda/src/dissoc'); var h = require('snabbdom/h'), s = require('./svg'); @@ -404,7 +415,7 @@ var statusLabel = function statusLabel(model) { var actionLabel = function actionLabel(action) { return ({ - 'abort': 'stop' + 'abort': '×' })[action] || null; }; @@ -424,7 +435,7 @@ var aborted = function aborted(model) { }; var abortable = function abortable(model) { - return !!model.abort && !!find(model.status, ['uploading']); + return !!model.abort && contains(model.status, ['uploading']); }; var hasProgressData = function hasProgressData(x) { @@ -438,17 +449,17 @@ var percentProgress = function percentProgress(p) { // action -// NOTE: no async tasks initiated, so all updates simply return changed state +// NOTE: no side-effects initiated, so all updates simply return changed state var Action = Type({ - Progress: [hasProgressData, Function], + Progress: [Function, hasProgressData], Uploaded: [], Error: [], Abort: [] }); var update = Action.caseOn({ - Progress: function Progress(_ref2, abort, model) { + Progress: function Progress(abort, _ref2, model) { var loaded = _ref2.loaded; var total = _ref2.total; @@ -469,43 +480,55 @@ var view = curry(function (_ref3, model) { progress = merge({ width: 200, height: 20 }, progress || {}); - return h('div.upload', {}, [h('div.title', ({})[renderTitle(model)]), h('div.progress', {}, [renderProgress(model, progress)]), h('div.status', {}, [renderStatus(model)]), h('div.abort', {}, [renderAbort(model)])]); + return h('div', { attrs: { 'class': 'upload ' + model.status }, + style: style.upload + }, [h('div.title', { style: style.div }, [renderTitle(model)]), h('div.size', { style: style.div }, ['' + size(model)]), h('div.progress', { style: style.div }, [renderProgress(model, progress)]), h('div.status', { style: style.div }, [renderStatus(model)]), h('div.abort', { style: dissoc('margin-right', style.div) }, [renderAbort(model)])]); }); -function renderTitle(model) { - var titlespan = h('span.title', {}, model.title); - var sizespan = h('span.size', {}, '' + size(model)); // TODO readable bytesize - return model.url ? h('a', { attr: { 'href': model.url, +var renderTitle = function renderTitle(model) { + return model.url ? h('a', { attrs: { 'href': model.url, 'target': '_blank' } - }, [titlespan, sizespan]) : h('span', {}, [titlespan, sizespan]); -} + }, [model.title]) : h('span', {}, [model.title]); +}; -function renderProgress(model, specs) { +var renderProgress = function renderProgress(model, specs) { var barwidth = percentProgress(model.progress) * specs.width; var linespecs = { x1: specs.width, x2: specs.width, y1: 0, y2: specs.height }; - var rect = s('rect.bar', { attr: { height: specs.height, - width: barwidth + var rect = s('rect', { attrs: { height: specs.height, + width: barwidth, + 'class': 'bar' } }); - var line = s('line.end', { attr: linespecs }); + var line = s('line', { attrs: merge(linespecs, { 'class': 'end' }) }); - return s('svg', { attr: specs }, [s('g', {}, barwidth > 0 && uploading(model) ? [rect, line] : [])]); -} + return s('svg', { attrs: specs }, [s('g', {}, barwidth > 0 ? [rect, line] : [])]); +}; -function renderStatus(model) { - var label = statusLabel(model); - return h('span', {}, label); -} +var renderStatus = function renderStatus(model) { + return h('span', {}, statusLabel(model)); +}; -function renderAbort(model) { +var renderAbort = function renderAbort(model) { var label = actionLabel('abort'); - return h('a', { style: visible(abortable, model), + return h('a', { style: merge(visible(abortable, model), { cursor: 'pointer' }), on: { click: model.abort } }, label); -} +}; + +// view styles + +var style = { + upload: { 'display': 'inline-block' }, + div: { 'display': 'inline-block', + 'vertical-align': 'top', + 'margin-right': '1rem' + } +}; + +// view utils function visible(pred, model) { return { display: pred(model) ? null : 'none' }; @@ -513,14 +536,15 @@ function visible(pred, model) { module.exports = { init: init, Action: Action, update: update, view: view }; -},{"./svg":2,"ramda/src/always":12,"ramda/src/curry":16,"ramda/src/evolve":18,"ramda/src/find":19,"ramda/src/map":43,"ramda/src/merge":44,"ramda/src/reduce":46,"snabbdom/h":51,"union-type":73}],5:[function(require,module,exports){ +},{"./svg":2,"ramda/src/always":12,"ramda/src/contains":16,"ramda/src/curry":17,"ramda/src/dissoc":19,"ramda/src/evolve":21,"ramda/src/map":49,"ramda/src/merge":50,"ramda/src/reduce":52,"snabbdom/h":58,"union-type":80}],5:[function(require,module,exports){ /* globals XMLHttpRequest, FormData */ 'use strict'; var compose = require('ramda/src/compose'), __ = require('ramda/src/__'), - curry = require('ramda/src/curry'); + curry = require('ramda/src/curry'), + always = require('ramda/src/always'); var Type = require('union-type'); var Future = require('ramda-fantasy/src/Future'); @@ -534,12 +558,11 @@ var Result = Type({ Error: [Object], Abort: [Object], Unknown: [Object], - Progress: [Object, Function] + Progress: [Function, Object] }); var upload = curry(function (headers, url, files) { headers = headers || {}; - progress = progress || identity; return new Future(function (rej, res) { var xhr = new XMLHttpRequest(); @@ -549,7 +572,7 @@ var upload = curry(function (headers, url, files) { xhr.addEventListener('abort', compose(res, Result.Abort, getxhr), false); xhr.addEventListener('error', compose(res, Result.Error, getxhr), false); - xhr.upload.addEventListener('progress', compose(res, Result.Progress(__, abort)), false); + xhr.upload.addEventListener('progress', compose(res, Result.Progress(abort)), false); xhr.open('post', url, true); for (k in headers) { @@ -562,7 +585,7 @@ var upload = curry(function (headers, url, files) { module.exports = { upload: upload, Result: Result }; function deriveResult(xhr) { - return xhr.status < 400 ? Result.OK : xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : xhr.status >= 500 ? Result.Error : Result.Unknown; + return (xhr.status < 400 ? Result.OK : xhr.status >= 400 && xhr.status < 500 ? Result.NotFound : xhr.status >= 500 ? Result.Error : Result.Unknown)(xhr); } function formdata(files) { @@ -572,7 +595,7 @@ function formdata(files) { }return data; } -},{"ramda-fantasy/src/Future":6,"ramda/src/__":9,"ramda/src/compose":15,"ramda/src/curry":16,"union-type":73}],6:[function(require,module,exports){ +},{"ramda-fantasy/src/Future":6,"ramda/src/__":9,"ramda/src/always":12,"ramda/src/compose":15,"ramda/src/curry":17,"union-type":80}],6:[function(require,module,exports){ var R = require('ramda'); // `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success) @@ -8285,7 +8308,7 @@ module.exports = _curry3(function adjust(fn, idx, list) { return _list; }); -},{"./internal/_concat":22,"./internal/_curry3":25}],11:[function(require,module,exports){ +},{"./internal/_concat":25,"./internal/_curry3":29}],11:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _dispatchable = require('./internal/_dispatchable'); var _xall = require('./internal/_xall'); @@ -8325,7 +8348,7 @@ module.exports = _curry2(_dispatchable('all', _xall, function all(fn, list) { return true; })); -},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_xall":36}],12:[function(require,module,exports){ +},{"./internal/_curry2":28,"./internal/_dispatchable":31,"./internal/_xall":43}],12:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); @@ -8353,7 +8376,7 @@ module.exports = _curry1(function always(val) { }; }); -},{"./internal/_curry1":23}],13:[function(require,module,exports){ +},{"./internal/_curry1":27}],13:[function(require,module,exports){ var _concat = require('./internal/_concat'); var _curry2 = require('./internal/_curry2'); @@ -8381,7 +8404,7 @@ module.exports = _curry2(function append(el, list) { return _concat(list, [el]); }); -},{"./internal/_concat":22,"./internal/_curry2":24}],14:[function(require,module,exports){ +},{"./internal/_concat":25,"./internal/_curry2":28}],14:[function(require,module,exports){ var _arity = require('./internal/_arity'); var _curry2 = require('./internal/_curry2'); @@ -8407,7 +8430,7 @@ module.exports = _curry2(function bind(fn, thisObj) { }); }); -},{"./internal/_arity":20,"./internal/_curry2":24}],15:[function(require,module,exports){ +},{"./internal/_arity":23,"./internal/_curry2":28}],15:[function(require,module,exports){ var pipe = require('./pipe'); var reverse = require('./reverse'); @@ -8436,7 +8459,32 @@ module.exports = function compose() { return pipe.apply(this, reverse(arguments)); }; -},{"./pipe":45,"./reverse":47}],16:[function(require,module,exports){ +},{"./pipe":51,"./reverse":53}],16:[function(require,module,exports){ +var _contains = require('./internal/_contains'); +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns `true` if the specified value is equal, in `R.equals` terms, + * to at least one element of the given list; `false` otherwise. + * + * @func + * @memberOf R + * @category List + * @sig a -> [a] -> Boolean + * @param {Object} a The item to compare against. + * @param {Array} list The array to consider. + * @return {Boolean} `true` if the item is in the list, `false` otherwise. + * + * @example + * + * R.contains(3, [1, 2, 3]); //=> true + * R.contains(4, [1, 2, 3]); //=> false + * R.contains([42], [[42]]); //=> true + */ +module.exports = _curry2(_contains); + +},{"./internal/_contains":26,"./internal/_curry2":28}],17:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var curryN = require('./curryN'); @@ -8487,7 +8535,7 @@ module.exports = _curry1(function curry(fn) { return curryN(fn.length, fn); }); -},{"./curryN":17,"./internal/_curry1":23}],17:[function(require,module,exports){ +},{"./curryN":18,"./internal/_curry1":27}],18:[function(require,module,exports){ var _arity = require('./internal/_arity'); var _curry1 = require('./internal/_curry1'); var _curry2 = require('./internal/_curry2'); @@ -8544,7 +8592,69 @@ module.exports = _curry2(function curryN(length, fn) { return _arity(length, _curryN(length, [], fn)); }); -},{"./internal/_arity":20,"./internal/_curry1":23,"./internal/_curry2":24,"./internal/_curryN":26}],18:[function(require,module,exports){ +},{"./internal/_arity":23,"./internal/_curry1":27,"./internal/_curry2":28,"./internal/_curryN":30}],19:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); + + +/** + * Returns a new object that does not contain a `prop` property. + * + * @func + * @memberOf R + * @category Object + * @sig String -> {k: v} -> {k: v} + * @param {String} prop the name of the property to dissociate + * @param {Object} obj the object to clone + * @return {Object} a new object similar to the original but without the specified property + * @see R.assoc + * @example + * + * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} + */ +module.exports = _curry2(function dissoc(prop, obj) { + var result = {}; + for (var p in obj) { + if (p !== prop) { + result[p] = obj[p]; + } + } + return result; +}); + +},{"./internal/_curry2":28}],20:[function(require,module,exports){ +var _curry2 = require('./internal/_curry2'); +var _equals = require('./internal/_equals'); +var _hasMethod = require('./internal/_hasMethod'); + + +/** + * Returns `true` if its arguments are equivalent, `false` otherwise. + * Dispatches to an `equals` method if present. Handles cyclical data + * structures. + * + * @func + * @memberOf R + * @category Relation + * @sig a -> b -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} + * @example + * + * R.equals(1, 1); //=> true + * R.equals(1, '1'); //=> false + * R.equals([1, 2, 3], [1, 2, 3]); //=> true + * + * var a = {}; a.v = a; + * var b = {}; b.v = b; + * R.equals(a, b); //=> true + */ +module.exports = _curry2(function equals(a, b) { + return _hasMethod('equals', a) ? a.equals(b) : + _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []); +}); + +},{"./internal/_curry2":28,"./internal/_equals":32,"./internal/_hasMethod":34}],21:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -8585,45 +8695,44 @@ module.exports = _curry2(function evolve(transformations, object) { return result; }); -},{"./internal/_curry2":24}],19:[function(require,module,exports){ +},{"./internal/_curry2":28}],22:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); -var _dispatchable = require('./internal/_dispatchable'); -var _xfind = require('./internal/_xfind'); /** - * Returns the first element of the list which matches the predicate, or `undefined` if no - * element matches. - * - * Acts as a transducer if a transformer is given in list position. - * @see R.transduce + * Returns true if its arguments are identical, false otherwise. Values are + * identical if they reference the same memory. `NaN` is identical to `NaN`; + * `0` and `-0` are not identical. * * @func * @memberOf R - * @category List - * @sig (a -> Boolean) -> [a] -> a | undefined - * @param {Function} fn The predicate function used to determine if the element is the - * desired one. - * @param {Array} list The array to consider. - * @return {Object} The element found, or `undefined`. + * @category Relation + * @sig a -> a -> Boolean + * @param {*} a + * @param {*} b + * @return {Boolean} * @example * - * var xs = [{a: 1}, {a: 2}, {a: 3}]; - * R.find(R.propEq('a', 2))(xs); //=> {a: 2} - * R.find(R.propEq('a', 4))(xs); //=> undefined + * var o = {}; + * R.identical(o, o); //=> true + * R.identical(1, 1); //=> true + * R.identical(1, '1'); //=> false + * R.identical([], []); //=> false + * R.identical(0, -0); //=> false + * R.identical(NaN, NaN); //=> true */ -module.exports = _curry2(_dispatchable('find', _xfind, function find(fn, list) { - var idx = 0; - var len = list.length; - while (idx < len) { - if (fn(list[idx])) { - return list[idx]; - } - idx += 1; +module.exports = _curry2(function identical(a, b) { + // SameValue algorithm + if (a === b) { // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + return a !== 0 || 1 / a === 1 / b; + } else { + // Step 6.a: NaN == NaN + return a !== a && b !== b; } -})); +}); -},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_xfind":38}],20:[function(require,module,exports){ +},{"./internal/_curry2":28}],23:[function(require,module,exports){ module.exports = function _arity(n, fn) { // jshint unused:vars switch (n) { @@ -8642,7 +8751,7 @@ module.exports = function _arity(n, fn) { } }; -},{}],21:[function(require,module,exports){ +},{}],24:[function(require,module,exports){ var _isArray = require('./_isArray'); var _slice = require('./_slice'); @@ -8670,7 +8779,7 @@ module.exports = function _checkForMethod(methodname, fn) { }; }; -},{"./_isArray":29,"./_slice":35}],22:[function(require,module,exports){ +},{"./_isArray":36,"./_slice":42}],25:[function(require,module,exports){ /** * Private `concat` function to merge two array-like objects. * @@ -8703,7 +8812,15 @@ module.exports = function _concat(set1, set2) { return result; }; -},{}],23:[function(require,module,exports){ +},{}],26:[function(require,module,exports){ +var _indexOf = require('./_indexOf'); + + +module.exports = function _contains(a, list) { + return _indexOf(list, a, 0) >= 0; +}; + +},{"./_indexOf":35}],27:[function(require,module,exports){ /** * Optimized internal two-arity curry function. * @@ -8724,7 +8841,7 @@ module.exports = function _curry1(fn) { }; }; -},{}],24:[function(require,module,exports){ +},{}],28:[function(require,module,exports){ var _curry1 = require('./_curry1'); @@ -8758,7 +8875,7 @@ module.exports = function _curry2(fn) { }; }; -},{"./_curry1":23}],25:[function(require,module,exports){ +},{"./_curry1":27}],29:[function(require,module,exports){ var _curry1 = require('./_curry1'); var _curry2 = require('./_curry2'); @@ -8814,7 +8931,7 @@ module.exports = function _curry3(fn) { }; }; -},{"./_curry1":23,"./_curry2":24}],26:[function(require,module,exports){ +},{"./_curry1":27,"./_curry2":28}],30:[function(require,module,exports){ var _arity = require('./_arity'); @@ -8854,7 +8971,7 @@ module.exports = function _curryN(length, received, fn) { }; }; -},{"./_arity":20}],27:[function(require,module,exports){ +},{"./_arity":23}],31:[function(require,module,exports){ var _isArray = require('./_isArray'); var _isTransformer = require('./_isTransformer'); var _slice = require('./_slice'); @@ -8895,12 +9012,121 @@ module.exports = function _dispatchable(methodname, xf, fn) { }; }; -},{"./_isArray":29,"./_isTransformer":30,"./_slice":35}],28:[function(require,module,exports){ +},{"./_isArray":36,"./_isTransformer":37,"./_slice":42}],32:[function(require,module,exports){ +var _has = require('./_has'); +var identical = require('../identical'); +var keys = require('../keys'); +var type = require('../type'); + +// The algorithm used to handle cyclic structures is +// inspired by underscore's isEqual +module.exports = function _equals(a, b, stackA, stackB) { + var typeA = type(a); + if (typeA !== type(b)) { + return false; + } + + if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') { + return typeof a === 'object' ? + typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : + identical(a, b); + } + + if (identical(a, b)) { + return true; + } + + if (typeA === 'RegExp') { + // RegExp equality algorithm: http://stackoverflow.com/a/10776635 + return (a.source === b.source) && + (a.global === b.global) && + (a.ignoreCase === b.ignoreCase) && + (a.multiline === b.multiline) && + (a.sticky === b.sticky) && + (a.unicode === b.unicode); + } + + if (Object(a) === a) { + if (typeA === 'Date' && a.getTime() !== b.getTime()) { + return false; + } + + var keysA = keys(a); + if (keysA.length !== keys(b).length) { + return false; + } + + var idx = stackA.length - 1; + while (idx >= 0) { + if (stackA[idx] === a) { + return stackB[idx] === b; + } + idx -= 1; + } + + stackA[stackA.length] = a; + stackB[stackB.length] = b; + idx = keysA.length - 1; + while (idx >= 0) { + var key = keysA[idx]; + if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) { + return false; + } + idx -= 1; + } + stackA.pop(); + stackB.pop(); + return true; + } + return false; +}; + +},{"../identical":22,"../keys":48,"../type":56,"./_has":33}],33:[function(require,module,exports){ module.exports = function _has(prop, obj) { return Object.prototype.hasOwnProperty.call(obj, prop); }; -},{}],29:[function(require,module,exports){ +},{}],34:[function(require,module,exports){ +var _isArray = require('./_isArray'); + + +/** + * Private function that determines whether or not a provided object has a given method. + * Does not ignore methods stored on the object's prototype chain. Used for dynamically + * dispatching Ramda methods to non-Array objects. + * + * @private + * @param {String} methodName The name of the method to check for. + * @param {Object} obj The object to test. + * @return {Boolean} `true` has a given method, `false` otherwise. + * @example + * + * var person = { name: 'John' }; + * person.shout = function() { alert(this.name); }; + * + * _hasMethod('shout', person); //=> true + * _hasMethod('foo', person); //=> false + */ +module.exports = function _hasMethod(methodName, obj) { + return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function'; +}; + +},{"./_isArray":36}],35:[function(require,module,exports){ +var equals = require('../equals'); + + +module.exports = function _indexOf(list, item, from) { + var idx = from; + while (idx < list.length) { + if (equals(list[idx], item)) { + return idx; + } + idx += 1; + } + return -1; +}; + +},{"../equals":20}],36:[function(require,module,exports){ /** * Tests whether or not an object is an array. * @@ -8919,12 +9145,12 @@ module.exports = Array.isArray || function _isArray(val) { Object.prototype.toString.call(val) === '[object Array]'); }; -},{}],30:[function(require,module,exports){ +},{}],37:[function(require,module,exports){ module.exports = function _isTransformer(obj) { return typeof obj['@@transducer/step'] === 'function'; }; -},{}],31:[function(require,module,exports){ +},{}],38:[function(require,module,exports){ module.exports = function _map(fn, list) { var idx = 0, len = list.length, result = Array(len); while (idx < len) { @@ -8934,14 +9160,14 @@ module.exports = function _map(fn, list) { return result; }; -},{}],32:[function(require,module,exports){ +},{}],39:[function(require,module,exports){ module.exports = function _pipe(f, g) { return function() { return g.call(this, f.apply(this, arguments)); }; }; -},{}],33:[function(require,module,exports){ +},{}],40:[function(require,module,exports){ var _xwrap = require('./_xwrap'); var bind = require('../bind'); var isArrayLike = require('../isArrayLike'); @@ -8999,7 +9225,7 @@ module.exports = (function() { }; })(); -},{"../bind":14,"../isArrayLike":41,"./_xwrap":40}],34:[function(require,module,exports){ +},{"../bind":14,"../isArrayLike":47,"./_xwrap":46}],41:[function(require,module,exports){ module.exports = function _reduced(x) { return x && x['@@transducer/reduced'] ? x : { @@ -9008,7 +9234,7 @@ module.exports = function _reduced(x) { }; }; -},{}],35:[function(require,module,exports){ +},{}],42:[function(require,module,exports){ /** * An optimized, private array `slice` implementation. * @@ -9042,7 +9268,7 @@ module.exports = function _slice(args, from, to) { } }; -},{}],36:[function(require,module,exports){ +},{}],43:[function(require,module,exports){ var _curry2 = require('./_curry2'); var _reduced = require('./_reduced'); var _xfBase = require('./_xfBase'); @@ -9072,7 +9298,7 @@ module.exports = (function() { return _curry2(function _xall(f, xf) { return new XAll(f, xf); }); })(); -},{"./_curry2":24,"./_reduced":34,"./_xfBase":37}],37:[function(require,module,exports){ +},{"./_curry2":28,"./_reduced":41,"./_xfBase":44}],44:[function(require,module,exports){ module.exports = { init: function() { return this.xf['@@transducer/init'](); @@ -9082,37 +9308,7 @@ module.exports = { } }; -},{}],38:[function(require,module,exports){ -var _curry2 = require('./_curry2'); -var _reduced = require('./_reduced'); -var _xfBase = require('./_xfBase'); - - -module.exports = (function() { - function XFind(f, xf) { - this.xf = xf; - this.f = f; - this.found = false; - } - XFind.prototype['@@transducer/init'] = _xfBase.init; - XFind.prototype['@@transducer/result'] = function(result) { - if (!this.found) { - result = this.xf['@@transducer/step'](result, void 0); - } - return this.xf['@@transducer/result'](result); - }; - XFind.prototype['@@transducer/step'] = function(result, input) { - if (this.f(input)) { - this.found = true; - result = _reduced(this.xf['@@transducer/step'](result, input)); - } - return result; - }; - - return _curry2(function _xfind(f, xf) { return new XFind(f, xf); }); -})(); - -},{"./_curry2":24,"./_reduced":34,"./_xfBase":37}],39:[function(require,module,exports){ +},{}],45:[function(require,module,exports){ var _curry2 = require('./_curry2'); var _xfBase = require('./_xfBase'); @@ -9131,7 +9327,7 @@ module.exports = (function() { return _curry2(function _xmap(f, xf) { return new XMap(f, xf); }); })(); -},{"./_curry2":24,"./_xfBase":37}],40:[function(require,module,exports){ +},{"./_curry2":28,"./_xfBase":44}],46:[function(require,module,exports){ module.exports = (function() { function XWrap(fn) { this.f = fn; @@ -9147,7 +9343,7 @@ module.exports = (function() { return function _xwrap(fn) { return new XWrap(fn); }; }()); -},{}],41:[function(require,module,exports){ +},{}],47:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _isArray = require('./internal/_isArray'); @@ -9183,7 +9379,7 @@ module.exports = _curry1(function isArrayLike(x) { return false; }); -},{"./internal/_curry1":23,"./internal/_isArray":29}],42:[function(require,module,exports){ +},{"./internal/_curry1":27,"./internal/_isArray":36}],48:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _has = require('./internal/_has'); @@ -9249,7 +9445,7 @@ module.exports = (function() { }); }()); -},{"./internal/_curry1":23,"./internal/_has":28}],43:[function(require,module,exports){ +},{"./internal/_curry1":27,"./internal/_has":33}],49:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _dispatchable = require('./internal/_dispatchable'); var _map = require('./internal/_map'); @@ -9284,7 +9480,7 @@ var _xmap = require('./internal/_xmap'); */ module.exports = _curry2(_dispatchable('map', _xmap, _map)); -},{"./internal/_curry2":24,"./internal/_dispatchable":27,"./internal/_map":31,"./internal/_xmap":39}],44:[function(require,module,exports){ +},{"./internal/_curry2":28,"./internal/_dispatchable":31,"./internal/_map":38,"./internal/_xmap":45}],50:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var keys = require('./keys'); @@ -9325,7 +9521,7 @@ module.exports = _curry2(function merge(a, b) { return result; }); -},{"./internal/_curry2":24,"./keys":42}],45:[function(require,module,exports){ +},{"./internal/_curry2":28,"./keys":48}],51:[function(require,module,exports){ var _pipe = require('./internal/_pipe'); var curryN = require('./curryN'); var reduce = require('./reduce'); @@ -9359,7 +9555,7 @@ module.exports = function pipe() { reduce(_pipe, arguments[0], tail(arguments))); }; -},{"./curryN":17,"./internal/_pipe":32,"./reduce":46,"./tail":49}],46:[function(require,module,exports){ +},{"./curryN":18,"./internal/_pipe":39,"./reduce":52,"./tail":55}],52:[function(require,module,exports){ var _curry3 = require('./internal/_curry3'); var _reduce = require('./internal/_reduce'); @@ -9397,7 +9593,7 @@ var _reduce = require('./internal/_reduce'); */ module.exports = _curry3(_reduce); -},{"./internal/_curry3":25,"./internal/_reduce":33}],47:[function(require,module,exports){ +},{"./internal/_curry3":29,"./internal/_reduce":40}],53:[function(require,module,exports){ var _curry1 = require('./internal/_curry1'); var _slice = require('./internal/_slice'); @@ -9423,7 +9619,7 @@ module.exports = _curry1(function reverse(list) { return _slice(list).reverse(); }); -},{"./internal/_curry1":23,"./internal/_slice":35}],48:[function(require,module,exports){ +},{"./internal/_curry1":27,"./internal/_slice":42}],54:[function(require,module,exports){ var _checkForMethod = require('./internal/_checkForMethod'); var _curry3 = require('./internal/_curry3'); @@ -9453,7 +9649,7 @@ module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIn return Array.prototype.slice.call(list, fromIndex, toIndex); })); -},{"./internal/_checkForMethod":21,"./internal/_curry3":25}],49:[function(require,module,exports){ +},{"./internal/_checkForMethod":24,"./internal/_curry3":29}],55:[function(require,module,exports){ var _checkForMethod = require('./internal/_checkForMethod'); var slice = require('./slice'); @@ -9484,7 +9680,38 @@ var slice = require('./slice'); */ module.exports = _checkForMethod('tail', slice(1, Infinity)); -},{"./internal/_checkForMethod":21,"./slice":48}],50:[function(require,module,exports){ +},{"./internal/_checkForMethod":24,"./slice":54}],56:[function(require,module,exports){ +var _curry1 = require('./internal/_curry1'); + + +/** + * Gives a single-word string description of the (native) type of a value, returning such + * answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user + * Object types any further, reporting them all as 'Object'. + * + * @func + * @memberOf R + * @category Type + * @sig (* -> {*}) -> String + * @param {*} val The value to test + * @return {String} + * @example + * + * R.type({}); //=> "Object" + * R.type(1); //=> "Number" + * R.type(false); //=> "Boolean" + * R.type('s'); //=> "String" + * R.type(null); //=> "Null" + * R.type([]); //=> "Array" + * R.type(/[A-z]/); //=> "RegExp" + */ +module.exports = _curry1(function type(val) { + return val === null ? 'Null' : + val === undefined ? 'Undefined' : + Object.prototype.toString.call(val).slice(8, -1); +}); + +},{"./internal/_curry1":27}],57:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -9516,7 +9743,7 @@ module.exports = _curry2(function zip(a, b) { return rv; }); -},{"./internal/_curry2":24}],51:[function(require,module,exports){ +},{"./internal/_curry2":28}],58:[function(require,module,exports){ var VNode = require('./vnode'); var is = require('./is'); @@ -9539,20 +9766,20 @@ module.exports = function h(sel, b, c) { return VNode(sel, data, children, text, undefined); }; -},{"./is":52,"./vnode":53}],52:[function(require,module,exports){ +},{"./is":59,"./vnode":60}],59:[function(require,module,exports){ module.exports = { array: Array.isArray, primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; }, }; -},{}],53:[function(require,module,exports){ +},{}],60:[function(require,module,exports){ module.exports = function(sel, data, children, text, elm) { var key = data === undefined ? undefined : data.key; return {sel: sel, data: data, children: children, text: text, elm: elm, key: key}; }; -},{}],54:[function(require,module,exports){ +},{}],61:[function(require,module,exports){ (function (process){ var defined = require('defined'); var createDefaultStream = require('./lib/default_stream'); @@ -9698,7 +9925,8 @@ function createHarness (conf_) { } }).call(this,require('_process')) -},{"./lib/default_stream":55,"./lib/results":56,"./lib/test":57,"_process":84,"defined":61,"through":67}],55:[function(require,module,exports){ + +},{"./lib/default_stream":62,"./lib/results":63,"./lib/test":64,"_process":91,"defined":68,"through":74}],62:[function(require,module,exports){ (function (process){ var through = require('through'); var fs = require('fs'); @@ -9733,7 +9961,8 @@ module.exports = function () { }; }).call(this,require('_process')) -},{"_process":84,"fs":74,"through":67}],56:[function(require,module,exports){ + +},{"_process":91,"fs":81,"through":74}],63:[function(require,module,exports){ (function (process){ var EventEmitter = require('events').EventEmitter; var inherits = require('inherits'); @@ -9929,7 +10158,8 @@ function invalidYaml (str) { } }).call(this,require('_process')) -},{"_process":84,"events":80,"function-bind":62,"has":63,"inherits":64,"object-inspect":65,"resumer":66,"through":67}],57:[function(require,module,exports){ + +},{"_process":91,"events":87,"function-bind":69,"has":70,"inherits":71,"object-inspect":72,"resumer":73,"through":74}],64:[function(require,module,exports){ (function (process,__dirname){ var deepEqual = require('deep-equal'); var defined = require('defined'); @@ -10426,7 +10656,8 @@ Test.skip = function (name_, _opts, _cb) { }).call(this,require('_process'),"/node_modules/tape/lib") -},{"_process":84,"deep-equal":58,"defined":61,"events":80,"has":63,"inherits":64,"path":83}],58:[function(require,module,exports){ + +},{"_process":91,"deep-equal":65,"defined":68,"events":87,"has":70,"inherits":71,"path":90}],65:[function(require,module,exports){ var pSlice = Array.prototype.slice; var objectKeys = require('./lib/keys.js'); var isArguments = require('./lib/is_arguments.js'); @@ -10442,7 +10673,7 @@ var deepEqual = module.exports = function (actual, expected, opts) { // 7.3. Other pairs that do not both pass typeof value == 'object', // equivalence is determined by ==. - } else if (typeof actual != 'object' && typeof expected != 'object') { + } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') { return opts.strict ? actual === expected : actual == expected; // 7.4. For all other Object pairs, including Array objects, equivalence is @@ -10522,7 +10753,7 @@ function objEquiv(a, b, opts) { return typeof a === typeof b; } -},{"./lib/is_arguments.js":59,"./lib/keys.js":60}],59:[function(require,module,exports){ +},{"./lib/is_arguments.js":66,"./lib/keys.js":67}],66:[function(require,module,exports){ var supportsArgumentsClass = (function(){ return Object.prototype.toString.call(arguments) })() == '[object Arguments]'; @@ -10544,7 +10775,7 @@ function unsupported(object){ false; }; -},{}],60:[function(require,module,exports){ +},{}],67:[function(require,module,exports){ exports = module.exports = typeof Object.keys === 'function' ? Object.keys : shim; @@ -10555,14 +10786,14 @@ function shim (obj) { return keys; } -},{}],61:[function(require,module,exports){ +},{}],68:[function(require,module,exports){ module.exports = function () { for (var i = 0; i < arguments.length; i++) { if (arguments[i] !== undefined) return arguments[i]; } }; -},{}],62:[function(require,module,exports){ +},{}],69:[function(require,module,exports){ var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; var slice = Array.prototype.slice; var toStr = Object.prototype.toString; @@ -10612,12 +10843,12 @@ module.exports = function bind(that) { }; -},{}],63:[function(require,module,exports){ +},{}],70:[function(require,module,exports){ var bind = require('function-bind'); module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty); -},{"function-bind":62}],64:[function(require,module,exports){ +},{"function-bind":69}],71:[function(require,module,exports){ if (typeof Object.create === 'function') { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { @@ -10642,7 +10873,7 @@ if (typeof Object.create === 'function') { } } -},{}],65:[function(require,module,exports){ +},{}],72:[function(require,module,exports){ module.exports = function inspect_ (obj, opts, depth, seen) { if (!opts) opts = {}; @@ -10791,7 +11022,7 @@ function inspectString (str) { } } -},{}],66:[function(require,module,exports){ +},{}],73:[function(require,module,exports){ (function (process){ var through = require('through'); var nextTick = typeof setImmediate !== 'undefined' @@ -10824,7 +11055,8 @@ module.exports = function (write, end) { }; }).call(this,require('_process')) -},{"_process":84,"through":67}],67:[function(require,module,exports){ + +},{"_process":91,"through":74}],74:[function(require,module,exports){ (function (process){ var Stream = require('stream') @@ -10936,7 +11168,8 @@ function through (write, end, opts) { }).call(this,require('_process')) -},{"_process":84,"stream":96}],68:[function(require,module,exports){ + +},{"_process":91,"stream":103}],75:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); @@ -10985,7 +11218,7 @@ module.exports = _curry2(function(n, fn) { } }); -},{"./internal/_curry2":71}],69:[function(require,module,exports){ +},{"./internal/_curry2":78}],76:[function(require,module,exports){ var _curry2 = require('./internal/_curry2'); var _curryN = require('./internal/_curryN'); var arity = require('./arity'); @@ -11038,7 +11271,7 @@ module.exports = _curry2(function curryN(length, fn) { return arity(length, _curryN(length, [], fn)); }); -},{"./arity":68,"./internal/_curry2":71,"./internal/_curryN":72}],70:[function(require,module,exports){ +},{"./arity":75,"./internal/_curry2":78,"./internal/_curryN":79}],77:[function(require,module,exports){ /** * Optimized internal two-arity curry function. * @@ -11059,9 +11292,9 @@ module.exports = function _curry1(fn) { }; }; -},{}],71:[function(require,module,exports){ -arguments[4][24][0].apply(exports,arguments) -},{"./_curry1":70,"dup":24}],72:[function(require,module,exports){ +},{}],78:[function(require,module,exports){ +arguments[4][28][0].apply(exports,arguments) +},{"./_curry1":77,"dup":28}],79:[function(require,module,exports){ var arity = require('../arity'); @@ -11101,7 +11334,7 @@ module.exports = function _curryN(length, received, fn) { }; }; -},{"../arity":68}],73:[function(require,module,exports){ +},{"../arity":75}],80:[function(require,module,exports){ var curryN = require('ramda/src/curryN'); function isString(s) { return typeof s === 'string'; } @@ -11171,11 +11404,11 @@ function Type(desc) { module.exports = Type; -},{"ramda/src/curryN":69}],74:[function(require,module,exports){ +},{"ramda/src/curryN":76}],81:[function(require,module,exports){ -},{}],75:[function(require,module,exports){ -arguments[4][74][0].apply(exports,arguments) -},{"dup":74}],76:[function(require,module,exports){ +},{}],82:[function(require,module,exports){ +arguments[4][81][0].apply(exports,arguments) +},{"dup":81}],83:[function(require,module,exports){ /*! * The buffer module from node.js, for the browser. * @@ -12591,7 +12824,7 @@ function decodeUtf8Char (str) { } } -},{"base64-js":77,"ieee754":78,"is-array":79}],77:[function(require,module,exports){ +},{"base64-js":84,"ieee754":85,"is-array":86}],84:[function(require,module,exports){ var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; ;(function (exports) { @@ -12717,7 +12950,7 @@ var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; exports.fromByteArray = uint8ToBase64 }(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) -},{}],78:[function(require,module,exports){ +},{}],85:[function(require,module,exports){ exports.read = function (buffer, offset, isLE, mLen, nBytes) { var e, m var eLen = nBytes * 8 - mLen - 1 @@ -12803,7 +13036,7 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { buffer[offset + i - d] |= s * 128 } -},{}],79:[function(require,module,exports){ +},{}],86:[function(require,module,exports){ /** * isArray @@ -12838,7 +13071,7 @@ module.exports = isArray || function (val) { return !! val && '[object Array]' == str.call(val); }; -},{}],80:[function(require,module,exports){ +},{}],87:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -13141,14 +13374,14 @@ function isUndefined(arg) { return arg === void 0; } -},{}],81:[function(require,module,exports){ -arguments[4][64][0].apply(exports,arguments) -},{"dup":64}],82:[function(require,module,exports){ +},{}],88:[function(require,module,exports){ +arguments[4][71][0].apply(exports,arguments) +},{"dup":71}],89:[function(require,module,exports){ module.exports = Array.isArray || function (arr) { return Object.prototype.toString.call(arr) == '[object Array]'; }; -},{}],83:[function(require,module,exports){ +},{}],90:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -13376,7 +13609,8 @@ var substr = 'ab'.substr(-1) === 'b' ; }).call(this,require('_process')) -},{"_process":84}],84:[function(require,module,exports){ + +},{"_process":91}],91:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {}; @@ -13468,10 +13702,10 @@ process.chdir = function (dir) { }; process.umask = function() { return 0; }; -},{}],85:[function(require,module,exports){ +},{}],92:[function(require,module,exports){ module.exports = require("./lib/_stream_duplex.js") -},{"./lib/_stream_duplex.js":86}],86:[function(require,module,exports){ +},{"./lib/_stream_duplex.js":93}],93:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -13564,7 +13798,8 @@ function forEach (xs, f) { } }).call(this,require('_process')) -},{"./_stream_readable":88,"./_stream_writable":90,"_process":84,"core-util-is":91,"inherits":81}],87:[function(require,module,exports){ + +},{"./_stream_readable":95,"./_stream_writable":97,"_process":91,"core-util-is":98,"inherits":88}],94:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -13612,7 +13847,7 @@ PassThrough.prototype._transform = function(chunk, encoding, cb) { cb(null, chunk); }; -},{"./_stream_transform":89,"core-util-is":91,"inherits":81}],88:[function(require,module,exports){ +},{"./_stream_transform":96,"core-util-is":98,"inherits":88}],95:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -14567,7 +14802,8 @@ function indexOf (xs, x) { } }).call(this,require('_process')) -},{"./_stream_duplex":86,"_process":84,"buffer":76,"core-util-is":91,"events":80,"inherits":81,"isarray":82,"stream":96,"string_decoder/":97,"util":75}],89:[function(require,module,exports){ + +},{"./_stream_duplex":93,"_process":91,"buffer":83,"core-util-is":98,"events":87,"inherits":88,"isarray":89,"stream":103,"string_decoder/":104,"util":82}],96:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -14778,7 +15014,7 @@ function done(stream, er) { return stream.push(null); } -},{"./_stream_duplex":86,"core-util-is":91,"inherits":81}],90:[function(require,module,exports){ +},{"./_stream_duplex":93,"core-util-is":98,"inherits":88}],97:[function(require,module,exports){ (function (process){ // Copyright Joyent, Inc. and other Node contributors. // @@ -15259,7 +15495,8 @@ function endWritable(stream, state, cb) { } }).call(this,require('_process')) -},{"./_stream_duplex":86,"_process":84,"buffer":76,"core-util-is":91,"inherits":81,"stream":96}],91:[function(require,module,exports){ + +},{"./_stream_duplex":93,"_process":91,"buffer":83,"core-util-is":98,"inherits":88,"stream":103}],98:[function(require,module,exports){ (function (Buffer){ // Copyright Joyent, Inc. and other Node contributors. // @@ -15369,10 +15606,11 @@ function objectToString(o) { return Object.prototype.toString.call(o); } }).call(this,require("buffer").Buffer) -},{"buffer":76}],92:[function(require,module,exports){ + +},{"buffer":83}],99:[function(require,module,exports){ module.exports = require("./lib/_stream_passthrough.js") -},{"./lib/_stream_passthrough.js":87}],93:[function(require,module,exports){ +},{"./lib/_stream_passthrough.js":94}],100:[function(require,module,exports){ exports = module.exports = require('./lib/_stream_readable.js'); exports.Stream = require('stream'); exports.Readable = exports; @@ -15381,13 +15619,13 @@ exports.Duplex = require('./lib/_stream_duplex.js'); exports.Transform = require('./lib/_stream_transform.js'); exports.PassThrough = require('./lib/_stream_passthrough.js'); -},{"./lib/_stream_duplex.js":86,"./lib/_stream_passthrough.js":87,"./lib/_stream_readable.js":88,"./lib/_stream_transform.js":89,"./lib/_stream_writable.js":90,"stream":96}],94:[function(require,module,exports){ +},{"./lib/_stream_duplex.js":93,"./lib/_stream_passthrough.js":94,"./lib/_stream_readable.js":95,"./lib/_stream_transform.js":96,"./lib/_stream_writable.js":97,"stream":103}],101:[function(require,module,exports){ module.exports = require("./lib/_stream_transform.js") -},{"./lib/_stream_transform.js":89}],95:[function(require,module,exports){ +},{"./lib/_stream_transform.js":96}],102:[function(require,module,exports){ module.exports = require("./lib/_stream_writable.js") -},{"./lib/_stream_writable.js":90}],96:[function(require,module,exports){ +},{"./lib/_stream_writable.js":97}],103:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -15516,7 +15754,7 @@ Stream.prototype.pipe = function(dest, options) { return dest; }; -},{"events":80,"inherits":81,"readable-stream/duplex.js":85,"readable-stream/passthrough.js":92,"readable-stream/readable.js":93,"readable-stream/transform.js":94,"readable-stream/writable.js":95}],97:[function(require,module,exports){ +},{"events":87,"inherits":88,"readable-stream/duplex.js":92,"readable-stream/passthrough.js":99,"readable-stream/readable.js":100,"readable-stream/transform.js":101,"readable-stream/writable.js":102}],104:[function(require,module,exports){ // Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a @@ -15739,4 +15977,5 @@ function base64DetectIncompleteChar(buffer) { this.charLength = this.charReceived ? 3 : 0; } -},{"buffer":76}]},{},[3]); +},{"buffer":83}]},{},[3]) +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/test.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/all.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_reduced.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_xall.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/type.js","node_modules/ramda/src/zip.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/vnode.js","node_modules/tape/index.js","node_modules/tape/lib/default_stream.js","node_modules/tape/lib/results.js","node_modules/tape/lib/test.js","node_modules/tape/node_modules/deep-equal/index.js","node_modules/tape/node_modules/deep-equal/lib/is_arguments.js","node_modules/tape/node_modules/deep-equal/lib/keys.js","node_modules/tape/node_modules/defined/index.js","node_modules/tape/node_modules/function-bind/index.js","node_modules/tape/node_modules/has/src/index.js","node_modules/tape/node_modules/inherits/inherits_browser.js","node_modules/tape/node_modules/object-inspect/index.js","node_modules/tape/node_modules/resumer/index.js","node_modules/tape/node_modules/through/index.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js","../../../../../../usr/lib/node_modules/browserify/lib/_empty.js","../../../../../../usr/lib/node_modules/browserify/node_modules/buffer/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/buffer/node_modules/base64-js/lib/b64.js","../../../../../../usr/lib/node_modules/browserify/node_modules/buffer/node_modules/ieee754/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/buffer/node_modules/is-array/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/events/events.js","../../../../../../usr/lib/node_modules/browserify/node_modules/isarray/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/path-browserify/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/process/browser.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/duplex.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/lib/_stream_duplex.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/lib/_stream_passthrough.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/lib/_stream_readable.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/lib/_stream_transform.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/lib/_stream_writable.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/node_modules/core-util-is/lib/util.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/passthrough.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/readable.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/transform.js","../../../../../../usr/lib/node_modules/browserify/node_modules/readable-stream/writable.js","../../../../../../usr/lib/node_modules/browserify/node_modules/stream-browserify/index.js","../../../../../../usr/lib/node_modules/browserify/node_modules/string_decoder/index.js"],"names":[],"mappings":"AAAA;;;ACAA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,CAAC,CAAC,MAAM,KAAK,SAAS;CAAA,CAAA;;;;AAIhD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACtD;CAEH,CAAC;;AAEF,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,CACzB,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CACF,CAAC,CACF;CACH,CAAA;;AAGD,IAAM,KAAK,GAAG;AACZ,IAAE,EAAE,EAAC,YAAY,EAAE,MAAM,EAAC;AAC1B,IAAE,EAAE,EAAG;CACR,CAAA;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;ACvF/C,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IACtB,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;;AAEvB,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAC7C,IAAM,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;AACzC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;;AAErC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAA;;;AAGzB,IAAM,cAAc,GAAG,SAAjB,cAAc,CAAI,KAAK,EAAE,MAAM,EAAE,IAAI,EAAK;AAC9C,SAAO,MAAM,CAAC,MAAM,CAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,MAAM,EAAN,MAAM,EAAC,CAAC,EAAE,IAAI,CAAE,CAAC;CAC5E,CAAA;;AAED,IAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;;AAE7D,IAAI,CAAC,+BAA+B,EAAE,UAAC,MAAM,EAAK;;AAEhD,MAAI,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,wBAAwB;AAC9B,QAAI,EAAE,iBAAiB,EAAC,CAC3B,CAAC,CAAC;AAC5B,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;AAC1D,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,wBAAwB,EAAE,OAAO,CAAC,CAAC;;AAE/D,SAAO,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;AAC1C,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAC3B,0CAA0C,CAAC,CAAC;AACzD,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;AACnD,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;;AAEnD,SAAO,GAAG,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAChD,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAC3B,gDAAgD,CAAC,CAAC;AAC/D,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,EAAE,oBAAoB,CAAC,CAAC;AACrE,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;;AAEnD,SAAO,GAAG,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;AAC5C,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,YAAY,EAC5B,6CAA6C,CAAC,CAAC;;AAE5D,SAAO,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;AAChC,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,EAC1B,uCAAuC,CAAC,CAAC;;AAEtD,QAAM,CAAC,GAAG,EAAE,CAAC;CACd,CAAC,CAAC;;AAEH,IAAI,CAAC,kCAAkC,EAAE,UAAC,MAAM,EAAK;;AAEnD,MAAI,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CACxB,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,CAC7C,CAAC,CAAC;;AAEH,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,yBAAyB,CAAC,CAAC;;AAEpE,QAAM,CAAC,GAAG,EAAE,CAAC;CACd,CAAC,CAAC;;;;AAKH,IAAM,aAAa,GAAG,KAAK,CAAE,UAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAK;AAClE,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAE,GAAG,EAAK;;AAE/B,QAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,MAAM,EAAE,KAAK,EAAK;AAClC,WAAK,GAAG,KAAK,GAAK,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,AAAE,CAAC;AACzC,gBAAU,CACR;eAAM,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAC,KAAK,EAAL,KAAK,EAAC,MAAM,EAAN,MAAM,EAAC,CAAC,CAAC;OAAA,EAC1D,KAAK,CACN,CAAC;AACF,aAAO,KAAK,CAAC;KACd,CAAA;;AAED,QAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAE,UAAC,KAAK,EAAC,IAAI;aAAK,QAAQ,CAAC,IAAI,EAAC,KAAK,CAAC;KAAA,EAAE,CAAC,CAAC,CAAC;;AAErE,QAAI,KAAK,EAAC;AACR,gBAAU,CACR;eAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;OAAA,EACpB,KAAK,GAAK,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,AAAE,CACjC,CAAC;KACH;GAEF,CAAC,CAAC;CACJ,CAAC,CAAC;;AAGH,IAAI,CAAC,gDAAgD,EAAE,UAAC,MAAM,EAAK;AACjE,QAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;;AAEnB,MAAI,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE;MAAE,KAAK,YAAA;MAAE,SAAS,GAAG,EAAE,CAAC;;AAEvD,MAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;6BACN,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;AAApD,WAAO;AAAE,SAAK;;AACf,OAAG,CAAC,UAAC,CAAC;aAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,eAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,AAAC,MAAM,GAAG,CAAA;OAAC,EAAE,MAAM,CAAC;KAAA,EAAE,KAAK,CAAC,CAAC;AAC5E,aAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxB,WAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;GACtB,CAAA;;AAED,MAAM,KAAK,GAAG,CAAC,CAAC,EAAC,CAAC,EAAC,EAAE,EAAC,EAAE,EAAC,GAAG,CAAC,CAAC;AAC9B,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;;AAEjD,QAAM,CACJ,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,CAC3B,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,CAC7C,CAAC,CACH,CAAC;;AAEF,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAW,CAAC,EAAE,6BAA6B,CAAC,CAAC;AACxE,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,kBAAkB,CAAC,CAAC;AAC7D,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,yBAAyB,CAAC,CAAC;AACvE,QAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,EAAG,SAAS,EAAE,gBAAgB,CAAC,CAAC;;AAE9D,YAAU,CAAE,YAAM;;AAEd,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,EAClC,qDAAqD,CAAC,CAAC;;AAEpE,UAAM,CAAC,EAAE,CAAE,GAAG,CAAE,UAAC,CAAC;aAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,WAAW;KAAA,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC,EAC9D,2DAA2D,CAAC,CAAC;;AAExE,UAAM,CAAC,EAAE,CAAE,GAAG,CAAE,UAAC,CAAC;aAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,YAAY;KAAA,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAC7D,0DAA0D,CAAC,CAAC;;AAEvE,UAAM,CAAC,EAAE,CAAE,GAAG,CAAE,UAAC,IAAQ;iCAAR,IAAQ;;UAAP,IAAI;UAAC,CAAC;aAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,IAAI;KAAA,EAC3C,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EACpC,iDAAiD,CAAC,CAAC;GAC/D,EACD,AAAC,KAAK,CAAC,MAAM,GAAE,IAAI;AAAA,GACpB,CAAC;CAEH,CAAC,CAAC;;AAEH,IAAI,CAAC,mEAAmE,EAAE,UAAC,MAAM,EAAK;AACpF,QAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;AAEf,MAAI,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE;MAAE,KAAK,YAAA;MAAE,SAAS,GAAG,EAAE,CAAC;;AAEvD,MAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;8BACN,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;AAApD,WAAO;AAAE,SAAK;;AACf,OAAG,CAAC,UAAC,CAAC;aAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,eAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,AAAC,MAAM,GAAG,CAAA;OAAC,EAAE,MAAM,CAAC;KAAA,EAAE,KAAK,CAAC,CAAC;AAC5E,aAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxB,WAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;GACtB,CAAA;;AAED,MAAM,OAAO,GAAG,SAAV,OAAO,CAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAK;AACpC,cAAU,CAAE,YAAM;AACd,YAAM,CACJ,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,CACpC,CAAC;KACH,EACD,KAAK,CACN,CAAC;GACH,CAAA;;AAED,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,GAAG,CAAC,CAAC;AAC7C,MAAM,MAAM,GAAG,CAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,EAAE,EAAC,GAAG,CAAC,CAAC;;AAEpC,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACjE,MAAM,GAAG,GAAG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;;AAEjE,SAAO,CAAE,GAAG,EACH,CAAE,EAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAC,CAAE,EAC1C,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAE,CAAC;;AAEhC,SAAO,CAAE,GAAG,EACH,CAAE,EAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,EAAC,CAAE,EAC3C,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAE,CAAC;;AAEhC,YAAU,CAAE,YAAM;AACd,QAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AAClD,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,GAAG,EACrB,EAAE,GAAG,GAAG,GAAG,MAAM,GACjB,uCAAuC,GACvC,iCAAiC,GACjC,kCAAkC,CAAC,CAAC;GAEnD,EACA,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAC,MAAM,CAAC,MAAM,CAAC,CAAA,GAAI,IAAI;AAAA,GACnD,CAAC;CAEH,CAAC,CAAC;;AAEH,IAAI,CAAC,iDAAiD,EAAE,UAAC,MAAM,EAAK;AAClE,QAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;AAEf,MAAI,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE;MAAE,KAAK,YAAA;MAAE,SAAS,GAAG,EAAE,CAAC;;AAEvD,MAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;8BACN,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;AAApD,WAAO;AAAE,SAAK;;AACf,OAAG,CAAC,UAAC,CAAC;aAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,eAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,AAAC,MAAM,GAAG,CAAA;OAAC,EAAE,MAAM,CAAC;KAAA,EAAE,KAAK,CAAC,CAAC;AAC5E,aAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxB,WAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;GACtB,CAAA;;AAED,MAAM,KAAK,GAAG,EAAE,CAAC;AACjB,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;;AAE/D,QAAM,CACJ,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,CAC3B,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,CAC7C,CAAC,CACH,CAAC;;AAEF,YAAU,CAAE,YAAM;;AAEd,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EACvB,qCAAqC,CAAC,CAAC;;AAEpD,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,UAAU,EAClC,iCAAiC,CAAC,CAAC;GAEjD,EACD,IAAI,CACL,CAAC;CAEH,CAAC,CAAC;;AAEH,IAAI,CAAC,oDAAoD,EAAE,UAAC,MAAM,EAAK;AACrE,QAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;AAEf,MAAI,OAAO,GAAG,UAAU,CAAC,IAAI,EAAE;MAAE,KAAK,YAAA;MAAE,SAAS,GAAG,EAAE,CAAC;;AAEvD,MAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;8BACN,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;AAApD,WAAO;AAAE,SAAK;;AACf,OAAG,CAAC,UAAC,CAAC;aAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,eAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,AAAC,MAAM,GAAG,CAAA;OAAC,EAAE,MAAM,CAAC;KAAA,EAAE,KAAK,CAAC,CAAC;AAC5E,aAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACxB,WAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;GACtB,CAAA;;AAED,MAAM,KAAK,GAAG,EAAE,CAAC;AACjB,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;;AAElE,QAAM,CACJ,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,CAC3B,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,EAC5C,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,EAAE,CAC7C,CAAC,CACH,CAAC;;AAEF,YAAU,CAAE,YAAM;;AAEd,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EACvB,qCAAqC,CAAC,CAAC;;AAEpD,UAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,EAC/B,oCAAoC,CAAC,CAAC;GAEpD,EACD,IAAI,CACL,CAAC;CAEH,CAAC,CAAC;;;;;AC1QH,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE;AAC5C,SAAK,EAAE,KAAK,CAAC,MAAM;GACpB,EAAG,CACX,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EAC1E,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EAC1E,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EAC1E,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EAC1E,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC,EACrB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC3E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH,CAAA;;AAGD,IAAM,cAAc,GAAG,SAAjB,cAAc,CAAI,KAAK,EAAC,KAAK,EAAK;AACtC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH,CAAA;;AAED,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,KAAK,EAAK;AAC9B,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;CAC1C,CAAA;;AAGD,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX,CAAA;;;;AAKD,IAAM,KAAK,GAAG;AACZ,QAAM,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;AACrC,KAAG,EAAK,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB;CACV,CAAA;;;;AAKD,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC9L9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AChMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7eA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC5GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACt4CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC7SA;AACA;AACA;AACA;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1FA;AACA;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACz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v7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7dA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1GA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst noFx = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => x.length !== undefined\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return noFx(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  return (\n    h('ul', {style: style.ul}, model.map( listItemView ) )\n  );\n\n};\n\nconst listItemView = (item, i) => {\n  return (\n    h('li', {style: style.li}, [\n      upload.view(\n        { progress: { height: 20, width: 200 } },\n        item\n      )   \n    ])\n  );\n}\n\n\nconst style = {\n  ul: {'list-style': 'none'},\n  li: { }\n}\n\n\nmodule.exports = { init, update, Action, view }\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const tape = require('tape')\n    , test = tape.test;\n\nconst compose = require('ramda/src/compose');\nconst curry = require('ramda/src/curry');\nconst map = require('ramda/src/map');\nconst all = require('ramda/src/all');\nconst zip = require('ramda/src/zip');\n\nconst Future = require('ramda-fantasy/src/Future');\n\nconst upload = require('./upload');\nconst uploadList = require('./list');\nconst uploader = require('./uploader');\n\nconst noop = function(){}\n\n/******************************************************************************/\nconst progressUpload = (total, loaded, data) => {\n  return upload.update( upload.Action.Progress(noop, {total,loaded}), data );\n}\n\nconst finishUpload = upload.update(upload.Action.Uploaded());\n\ntest('upload component, single file', (assert) => {\n  \n  let subject = upload.init([{ name: 'GreatAmericanNovel.pdf',\n                               type: 'application/pdf'}\n                           ]);\n  assert.equal(subject.status, 'initial', 'initial status');\n  assert.equal(subject.title, 'GreatAmericanNovel.pdf', 'title');\n  \n  subject = progressUpload(100, 1, subject);\n  assert.equal(subject.status, 'uploading', \n               'uploading status after progress action 1');\n  assert.equal(subject.progress.loaded, 1, 'loaded');\n  assert.equal(subject.progress.total, 100, 'total');\n\n  subject = progressUpload(100, 65.4321, subject);\n  assert.equal(subject.status, 'uploading', \n               'uploading status after progress action 65.4321');\n  assert.equal(subject.progress.loaded, 65.4321, 'loaded non-integer');\n  assert.equal(subject.progress.total, 100, 'total');\n\n  subject = progressUpload(100, 100, subject);\n  assert.equal(subject.status, 'processing', \n               'processing status after progress action 100');\n  \n  subject = finishUpload(subject);\n  assert.equal(subject.status, 'uploaded', \n               'uploaded status after uploaded action');\n\n  assert.end();\n});\n\ntest('upload component, multiple files', (assert) => {\n\n  let subject = upload.init([\n    { name: 'chapter1.txt', type: 'text/plain' },\n    { name: 'chapter2.txt', type: 'text/plain' },\n    { name: 'chapter3.txt', type: 'text/plain' }\n  ]);\n\n  assert.equal(subject.title, '(3 files)', 'title indicates 3 files');\n\n  assert.end();\n});\n\n\n/******************************************************************************/\n\nconst dummyUploader = curry( (total, steps, abort, final, files) => {\n  return new Future( (rej, res) => {\n    \n    const progress = (loaded, delay) => {\n      delay = delay + ( Math.random() * 2000 );\n      setTimeout( \n        () => res(uploader.Result.Progress(abort, {total,loaded})),\n        delay\n      );\n      return delay;\n    }\n\n    const delay = steps.reduce( (delay,step) => progress(step,delay), 0); \n\n    if (final){\n      setTimeout(\n        () => res(final({})),\n        delay + ( Math.random() * 2000 )\n      );\n    }\n\n  });\n});\n\n\ntest('upload list component, add file list, progress', (assert) => {\n  assert.plan(4 + 4);\n  \n  let subject = uploadList.init(), tasks, snapshots = [];\n  \n  const update = (action) => {\n    [subject, tasks] = uploadList.update(action, subject);\n    map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks);\n    snapshots.push(subject);\n    console.log(subject);\n  }\n  \n  const steps = [1,3,10,19,100];\n  const up = dummyUploader(100, steps, noop, null);\n\n  update( \n    uploadList.Action.Create(up, [\n      { name: 'chapter1.txt', type: 'text/plain' },\n      { name: 'chapter2.txt', type: 'text/plain' },\n      { name: 'chapter3.txt', type: 'text/plain' }\n    ])\n  );\n\n  assert.equal(subject.length,          1, 'upload list has 1 file list');\n  assert.equal(subject[0].files.length, 3, '3 files in group');\n  assert.equal(subject[0].title, '(3 files)', 'title indicates 3 files');\n  assert.equal(subject[0].status,  'initial', 'initial status');\n\n  setTimeout( () => {\n      \n      assert.equal(snapshots.length, steps.length + 1,  \n                   '1 initial transition + 1 per expected progress step');\n\n      assert.ok( all( (s) => s[0].status == 'uploading', snapshots.slice(1,-1)),\n                 'uploading status after each progress step except the last');\n\n      assert.ok( all( (s) => s[0].status == 'processing', snapshots.slice(-1)),\n                 'processing status after loaded 100% of total (last step)');\n\n      assert.ok( all( ([step,s]) => s[0].progress.loaded === step, \n                      zip(steps, snapshots.slice(1))),\n                 'expected loading progress at each progress step'); \n    },\n    (steps.length)*2000  // max time for steps to complete\n  );\n   \n});\n\ntest('upload list component, add two file lists, progress independently', (assert) => {\n  assert.plan(1);\n  \n  let subject = uploadList.init(), tasks, snapshots = [];\n  \n  const update = (action) => {\n    [subject, tasks] = uploadList.update(action, subject);\n    map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks);\n    snapshots.push(subject);\n    console.log(subject);\n  }\n  \n  const trigger = (up, files, delay) => {\n    setTimeout( () => {\n        update(\n          uploadList.Action.Create(up, files)\n        );\n      },\n      delay\n    );\n  }\n\n  const steps1 = [1, 23,34,45,56,67,78,99,100];\n  const steps2 = [22,34,46,59,78,100];\n\n  const up1 = dummyUploader(100, steps1, noop, uploader.Result.OK);\n  const up2 = dummyUploader(100, steps2, noop, uploader.Result.OK);\n\n  trigger( up1, \n           [ {name: 'first.png', type: 'image/png'} ], \n           Math.random() * 2000 );\n\n  trigger( up2, \n           [ {name: 'second.png', type: 'image/png'} ], \n           Math.random() * 2000 );\n\n  setTimeout( () => {\n      const exp = 2 + steps1.length + steps2.length + 2;\n      assert.equal(snapshots.length, exp,  \n                   '' + exp + ' == ' + \n                   '1 initial transition per file list + ' + \n                   '1 per expected progress step + ' + \n                   '1 final transition per file list');\n\n   },\n    (4 + Math.max(steps1.length,steps2.length)) * 2000  // max time for steps to complete\n  );\n   \n});\n\ntest('upload list component, add file list, result ok', (assert) => {\n  assert.plan(2);\n  \n  let subject = uploadList.init(), tasks, snapshots = [];\n  \n  const update = (action) => {\n    [subject, tasks] = uploadList.update(action, subject);\n    map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks);\n    snapshots.push(subject);\n    console.log(subject);\n  }\n  \n  const steps = [];\n  const up = dummyUploader(100, steps, noop, uploader.Result.OK);\n\n  update( \n    uploadList.Action.Create(up, [\n      { name: 'chapter1.txt', type: 'text/plain' },\n      { name: 'chapter2.txt', type: 'text/plain' },\n      { name: 'chapter3.txt', type: 'text/plain' }\n    ])\n  );\n\n  setTimeout( () => {\n      \n      assert.equal(snapshots.length, 1 + 1,  \n                   '1 initial transition + 1 for result');\n\n      assert.equal(snapshots[1][0].status, 'uploaded', \n                   'status uploaded after result OK');\n\n    },\n    2000 \n  );\n   \n});\n\ntest('upload list component, add file list, result error', (assert) => {\n  assert.plan(2);\n  \n  let subject = uploadList.init(), tasks, snapshots = [];\n  \n  const update = (action) => {\n    [subject, tasks] = uploadList.update(action, subject);\n    map((a) => a.fork((err) => {console.error(err); throw err}, update), tasks);\n    snapshots.push(subject);\n    console.log(subject);\n  }\n  \n  const steps = [];\n  const up = dummyUploader(100, steps, noop, uploader.Result.Error);\n\n  update( \n    uploadList.Action.Create(up, [\n      { name: 'chapter1.txt', type: 'text/plain' },\n      { name: 'chapter2.txt', type: 'text/plain' },\n      { name: 'chapter3.txt', type: 'text/plain' }\n    ])\n  );\n\n  setTimeout( () => {\n      \n      assert.equal(snapshots.length, 1 + 1,  \n                   '1 initial transition + 1 for result');\n\n      assert.equal(snapshots[1][0].status, 'error', \n                   'status uploaded after result error');\n\n    },\n    2000 \n  );\n   \n});\n\n\n\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no side-effects initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, \n               style: style.upload \n             },  [\n      h('div.title',    {style: style.div},  [ renderTitle(model)             ]),\n      h('div.size',     {style: style.div},  [ ''+size(model)                 ]),\n      h('div.progress', {style: style.div},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: style.div},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right', style.div)},   \n                                             [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nconst renderTitle = (model) => {\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nconst renderProgress = (model,specs) => {\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nconst renderStatus = (model) => {\n  return h('span', {}, statusLabel(model));\n}\n\n\nconst renderAbort = (model) => {\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\n\n// view styles \n\nconst style = { \n  upload: { 'display': 'inline-block' }, \n  div:    { 'display': 'inline-block',\n            'vertical-align': 'top',\n            'margin-right': '1rem'\n          }\n}\n\n\n// view utils\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xall = require('./internal/_xall');\n\n\n/**\n * Returns `true` if all elements of the list match the predicate, `false` if there are any\n * that don't.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n *         otherwise.\n * @see R.any, R.none\n * @example\n *\n *      var lessThan2 = R.flip(R.lt)(2);\n *      var lessThan3 = R.flip(R.lt)(3);\n *      R.all(lessThan2)([1, 2]); //=> false\n *      R.all(lessThan3)([1, 2]); //=> true\n */\nmodule.exports = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n  var idx = 0;\n  while (idx < list.length) {\n    if (!fn(list[idx])) {\n      return false;\n    }\n    idx += 1;\n  }\n  return true;\n}));\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","module.exports = function _reduced(x) {\n  return x && x['@@transducer/reduced'] ? x :\n    {\n      '@@transducer/value': x,\n      '@@transducer/reduced': true\n    };\n};\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XAll(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.all = true;\n  }\n  XAll.prototype['@@transducer/init'] = _xfBase.init;\n  XAll.prototype['@@transducer/result'] = function(result) {\n    if (this.all) {\n      result = this.xf['@@transducer/step'](result, true);\n    }\n    return this.xf['@@transducer/result'](result);\n  };\n  XAll.prototype['@@transducer/step'] = function(result, input) {\n    if (!this.f(input)) {\n      this.all = false;\n      result = _reduced(this.xf['@@transducer/step'](result, false));\n    }\n    return result;\n  };\n\n  return _curry2(function _xall(f, xf) { return new XAll(f, xf); });\n})();\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new list out of the two supplied by pairing up\n * equally-positioned items from both lists.  The returned list is\n * truncated to the length of the shorter of the two input lists.\n * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n * @example\n *\n *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n */\nmodule.exports = _curry2(function zip(a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n  while (idx < len) {\n    rv[idx] = [a[idx], b[idx]];\n    idx += 1;\n  }\n  return rv;\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var defined = require('defined');\nvar createDefaultStream = require('./lib/default_stream');\nvar Test = require('./lib/test');\nvar createResult = require('./lib/results');\nvar through = require('through');\n\nvar canEmitExit = typeof process !== 'undefined' && process\n    && typeof process.on === 'function' && process.browser !== true\n;\nvar canExit = typeof process !== 'undefined' && process\n    && typeof process.exit === 'function'\n;\n\nvar nextTick = typeof setImmediate !== 'undefined'\n    ? setImmediate\n    : process.nextTick\n;\n\nexports = module.exports = (function () {\n    var harness;\n    var lazyLoad = function () {\n        return getHarness().apply(this, arguments);\n    };\n    \n    lazyLoad.only = function () {\n        return getHarness().only.apply(this, arguments);\n    };\n    \n    lazyLoad.createStream = function (opts) {\n        if (!opts) opts = {};\n        if (!harness) {\n            var output = through();\n            getHarness({ stream: output, objectMode: opts.objectMode });\n            return output;\n        }\n        return harness.createStream(opts);\n    };\n\n    lazyLoad.getHarness = getHarness\n\n    return lazyLoad\n\n    function getHarness (opts) {\n        if (!opts) opts = {};\n        opts.autoclose = !canEmitExit;\n        if (!harness) harness = createExitHarness(opts);\n        return harness;\n    }\n})();\n\nfunction createExitHarness (conf) {\n    if (!conf) conf = {};\n    var harness = createHarness({\n        autoclose: defined(conf.autoclose, false)\n    });\n    \n    var stream = harness.createStream({ objectMode: conf.objectMode });\n    var es = stream.pipe(conf.stream || createDefaultStream());\n    if (canEmitExit) {\n        es.on('error', function (err) { harness._exitCode = 1 });\n    }\n    \n    var ended = false;\n    stream.on('end', function () { ended = true });\n    \n    if (conf.exit === false) return harness;\n    if (!canEmitExit || !canExit) return harness;\n\n    var inErrorState = false;\n\n    process.on('exit', function (code) {\n        // let the process exit cleanly.\n        if (code !== 0) {\n            return\n        }\n\n        if (!ended) {\n            var only = harness._results._only;\n            for (var i = 0; i < harness._tests.length; i++) {\n                var t = harness._tests[i];\n                if (only && t.name !== only) continue;\n                t._exit();\n            }\n        }\n        harness.close();\n        process.exit(code || harness._exitCode);\n    });\n    \n    return harness;\n}\n\nexports.createHarness = createHarness;\nexports.Test = Test;\nexports.test = exports; // tap compat\nexports.test.skip = Test.skip;\n\nvar exitInterval;\n\nfunction createHarness (conf_) {\n    if (!conf_) conf_ = {};\n    var results = createResult();\n    if (conf_.autoclose !== false) {\n        results.once('done', function () { results.close() });\n    }\n    \n    var test = function (name, conf, cb) {\n        var t = new Test(name, conf, cb);\n        test._tests.push(t);\n        \n        (function inspectCode (st) {\n            st.on('test', function sub (st_) {\n                inspectCode(st_);\n            });\n            st.on('result', function (r) {\n                if (!r.ok && typeof r !== 'string') test._exitCode = 1\n            });\n        })(t);\n        \n        results.push(t);\n        return t;\n    };\n    test._results = results;\n    \n    test._tests = [];\n    \n    test.createStream = function (opts) {\n        return results.createStream(opts);\n    };\n    \n    var only = false;\n    test.only = function (name) {\n        if (only) throw new Error('there can only be one only test');\n        results.only(name);\n        only = true;\n        return test.apply(null, arguments);\n    };\n    test._exitCode = 0;\n    \n    test.close = function () { results.close() };\n    \n    return test;\n}\n","var through = require('through');\nvar fs = require('fs');\n\nmodule.exports = function () {\n    var line = '';\n    var stream = through(write, flush);\n    return stream;\n    \n    function write (buf) {\n        for (var i = 0; i < buf.length; i++) {\n            var c = typeof buf === 'string'\n                ? buf.charAt(i)\n                : String.fromCharCode(buf[i])\n            ;\n            if (c === '\\n') flush();\n            else line += c;\n        }\n    }\n    \n    function flush () {\n        if (fs.writeSync && /^win/.test(process.platform)) {\n            try { fs.writeSync(1, line + '\\n'); }\n            catch (e) { stream.emit('error', e) }\n        }\n        else {\n            try { console.log(line) }\n            catch (e) { stream.emit('error', e) }\n        }\n        line = '';\n    }\n};\n","var EventEmitter = require('events').EventEmitter;\nvar inherits = require('inherits');\nvar through = require('through');\nvar resumer = require('resumer');\nvar inspect = require('object-inspect');\nvar bind = require('function-bind');\nvar has = require('has');\nvar regexpTest = bind.call(Function.call, RegExp.prototype.test);\nvar yamlIndicators = /\\:|\\-|\\?/;\nvar nextTick = typeof setImmediate !== 'undefined'\n    ? setImmediate\n    : process.nextTick\n;\n\nmodule.exports = Results;\ninherits(Results, EventEmitter);\n\nfunction Results () {\n    if (!(this instanceof Results)) return new Results;\n    this.count = 0;\n    this.fail = 0;\n    this.pass = 0;\n    this._stream = through();\n    this.tests = [];\n}\n\nResults.prototype.createStream = function (opts) {\n    if (!opts) opts = {};\n    var self = this;\n    var output, testId = 0;\n    if (opts.objectMode) {\n        output = through();\n        self.on('_push', function ontest (t, extra) {\n            if (!extra) extra = {};\n            var id = testId++;\n            t.once('prerun', function () {\n                var row = {\n                    type: 'test',\n                    name: t.name,\n                    id: id\n                };\n                if (has(extra, 'parent')) {\n                    row.parent = extra.parent;\n                }\n                output.queue(row);\n            });\n            t.on('test', function (st) {\n                ontest(st, { parent: id });\n            });\n            t.on('result', function (res) {\n                res.test = id;\n                res.type = 'assert';\n                output.queue(res);\n            });\n            t.on('end', function () {\n                output.queue({ type: 'end', test: id });\n            });\n        });\n        self.on('done', function () { output.queue(null) });\n    }\n    else {\n        output = resumer();\n        output.queue('TAP version 13\\n');\n        self._stream.pipe(output);\n    }\n    \n    nextTick(function next() {\n        var t;\n        while (t = getNextTest(self)) {\n            t.run();\n            if (!t.ended) return t.once('end', function(){ nextTick(next); });\n        }\n        self.emit('done');\n    });\n    \n    return output;\n};\n\nResults.prototype.push = function (t) {\n    var self = this;\n    self.tests.push(t);\n    self._watch(t);\n    self.emit('_push', t);\n};\n\nResults.prototype.only = function (name) {\n    if (this._only) {\n        self.count ++;\n        self.fail ++;\n        write('not ok ' + self.count + ' already called .only()\\n');\n    }\n    this._only = name;\n};\n\nResults.prototype._watch = function (t) {\n    var self = this;\n    var write = function (s) { self._stream.queue(s) };\n    t.once('prerun', function () {\n        write('# ' + t.name + '\\n');\n    });\n    \n    t.on('result', function (res) {\n        if (typeof res === 'string') {\n            write('# ' + res + '\\n');\n            return;\n        }\n        write(encodeResult(res, self.count + 1));\n        self.count ++;\n\n        if (res.ok) self.pass ++\n        else self.fail ++\n    });\n    \n    t.on('test', function (st) { self._watch(st) });\n};\n\nResults.prototype.close = function () {\n    var self = this;\n    if (self.closed) self._stream.emit('error', new Error('ALREADY CLOSED'));\n    self.closed = true;\n    var write = function (s) { self._stream.queue(s) };\n    \n    write('\\n1..' + self.count + '\\n');\n    write('# tests ' + self.count + '\\n');\n    write('# pass  ' + self.pass + '\\n');\n    if (self.fail) write('# fail  ' + self.fail + '\\n')\n    else write('\\n# ok\\n')\n\n    self._stream.queue(null);\n};\n\nfunction encodeResult (res, count) {\n    var output = '';\n    output += (res.ok ? 'ok ' : 'not ok ') + count;\n    output += res.name ? ' ' + res.name.toString().replace(/\\s+/g, ' ') : '';\n    \n    if (res.skip) output += ' # SKIP';\n    else if (res.todo) output += ' # TODO';\n    \n    output += '\\n';\n    if (res.ok) return output;\n    \n    var outer = '  ';\n    var inner = outer + '  ';\n    output += outer + '---\\n';\n    output += inner + 'operator: ' + res.operator + '\\n';\n    \n    if (has(res, 'expected') || has(res, 'actual')) {\n        var ex = inspect(res.expected);\n        var ac = inspect(res.actual);\n        \n        if (Math.max(ex.length, ac.length) > 65 || invalidYaml(ex) || invalidYaml(ac)) {\n            output += inner + 'expected: |-\\n' + inner + '  ' + ex + '\\n';\n            output += inner + 'actual: |-\\n' + inner + '  ' + ac + '\\n';\n        }\n        else {\n            output += inner + 'expected: ' + ex + '\\n';\n            output += inner + 'actual:   ' + ac + '\\n';\n        }\n    }\n    if (res.at) {\n        output += inner + 'at: ' + res.at + '\\n';\n    }\n    if (res.operator === 'error' && res.actual && res.actual.stack) {\n        var lines = String(res.actual.stack).split('\\n');\n        output += inner + 'stack: |-\\n';\n        for (var i = 0; i < lines.length; i++) {\n            output += inner + '  ' + lines[i] + '\\n';\n        }\n    }\n    \n    output += outer + '...\\n';\n    return output;\n}\n\nfunction getNextTest (results) {\n    if (!results._only) {\n        return results.tests.shift();\n    }\n    \n    do {\n        var t = results.tests.shift();\n        if (!t) continue;\n        if (results._only === t.name) {\n            return t;\n        }\n    } while (results.tests.length !== 0)\n}\n\nfunction invalidYaml (str) {\n    return regexpTest(yamlIndicators, str);\n}\n","var deepEqual = require('deep-equal');\nvar defined = require('defined');\nvar path = require('path');\nvar inherits = require('inherits');\nvar EventEmitter = require('events').EventEmitter;\nvar has = require('has');\n\nmodule.exports = Test;\n\nvar nextTick = typeof setImmediate !== 'undefined'\n    ? setImmediate\n    : process.nextTick\n;\n\ninherits(Test, EventEmitter);\n\nvar getTestArgs = function (name_, opts_, cb_) {\n    var name = '(anonymous)';\n    var opts = {};\n    var cb;\n\n    for (var i = 0; i < arguments.length; i++) {\n        var arg = arguments[i];\n        var t = typeof arg;\n        if (t === 'string') {\n            name = arg;\n        }\n        else if (t === 'object') {\n            opts = arg || opts;\n        }\n        else if (t === 'function') {\n            cb = arg;\n        }\n    }\n    return { name: name, opts: opts, cb: cb };\n};\n\nfunction Test (name_, opts_, cb_) {\n    if (! (this instanceof Test)) {\n        return new Test(name_, opts_, cb_);\n    }\n\n    var args = getTestArgs(name_, opts_, cb_);\n\n    this.readable = true;\n    this.name = args.name || '(anonymous)';\n    this.assertCount = 0;\n    this.pendingCount = 0;\n    this._skip = args.opts.skip || false;\n    this._plan = undefined;\n    this._cb = args.cb;\n    this._progeny = [];\n    this._ok = true;\n\n    if (args.opts.timeout !== undefined) {\n        this.timeoutAfter(args.opts.timeout);\n    }\n\n    for (var prop in this) {\n        this[prop] = (function bind(self, val) {\n            if (typeof val === 'function') {\n                return function bound() {\n                    return val.apply(self, arguments);\n                };\n            }\n            else return val;\n        })(this, this[prop]);\n    }\n}\n\nTest.prototype.run = function () {\n    if (!this._cb || this._skip) {\n        return this._end();\n    }\n    this.emit('prerun');\n    this._cb(this);\n    this.emit('run');\n};\n\nTest.prototype.test = function (name, opts, cb) {\n    var self = this;\n    var t = new Test(name, opts, cb);\n    this._progeny.push(t);\n    this.pendingCount++;\n    this.emit('test', t);\n    t.on('prerun', function () {\n        self.assertCount++;\n    })\n    \n    if (!self._pendingAsserts()) {\n        nextTick(function () {\n            self._end();\n        });\n    }\n    \n    nextTick(function() {\n        if (!self._plan && self.pendingCount == self._progeny.length) {\n            self._end();\n        }\n    });\n};\n\nTest.prototype.comment = function (msg) {\n    this.emit('result', msg.trim().replace(/^#\\s*/, ''));\n};\n\nTest.prototype.plan = function (n) {\n    this._plan = n;\n    this.emit('plan', n);\n};\n\nTest.prototype.timeoutAfter = function(ms) {\n    if (!ms) throw new Error('timeoutAfter requires a timespan');\n    var self = this;\n    var timeout = setTimeout(function() {\n        self.fail('test timed out after ' + ms + 'ms');\n        self.end();\n    }, ms);\n    this.once('end', function() {\n        clearTimeout(timeout);\n    });\n}\n\nTest.prototype.end = function (err) { \n    var self = this;\n    if (arguments.length >= 1 && !!err) {\n        this.ifError(err);\n    }\n    \n    if (this.calledEnd) {\n        this.fail('.end() called twice');\n    }\n    this.calledEnd = true;\n    this._end();\n};\n\nTest.prototype._end = function (err) {\n    var self = this;\n    if (this._progeny.length) {\n        var t = this._progeny.shift();\n        t.on('end', function () { self._end() });\n        t.run();\n        return;\n    }\n    \n    if (!this.ended) this.emit('end');\n    var pendingAsserts = this._pendingAsserts();\n    if (!this._planError && this._plan !== undefined && pendingAsserts) {\n        this._planError = true;\n        this.fail('plan != count', {\n            expected : this._plan,\n            actual : this.assertCount\n        });\n    }\n    this.ended = true;\n};\n\nTest.prototype._exit = function () {\n    if (this._plan !== undefined &&\n        !this._planError && this.assertCount !== this._plan) {\n        this._planError = true;\n        this.fail('plan != count', {\n            expected : this._plan,\n            actual : this.assertCount,\n            exiting : true\n        });\n    }\n    else if (!this.ended) {\n        this.fail('test exited without ending', {\n            exiting: true\n        });\n    }\n};\n\nTest.prototype._pendingAsserts = function () {\n    if (this._plan === undefined) {\n        return 1;\n    }\n    else {\n        return this._plan - (this._progeny.length + this.assertCount);\n    }\n};\n\nTest.prototype._assert = function assert (ok, opts) {\n    var self = this;\n    var extra = opts.extra || {};\n    \n    var res = {\n        id : self.assertCount ++,\n        ok : Boolean(ok),\n        skip : defined(extra.skip, opts.skip),\n        name : defined(extra.message, opts.message, '(unnamed assert)'),\n        operator : defined(extra.operator, opts.operator)\n    };\n    if (has(opts, 'actual') || has(extra, 'actual')) {\n        res.actual = defined(extra.actual, opts.actual);\n    }\n    if (has(opts, 'expected') || has(extra, 'expected')) {\n        res.expected = defined(extra.expected, opts.expected);\n    }\n    this._ok = Boolean(this._ok && ok);\n    \n    if (!ok) {\n        res.error = defined(extra.error, opts.error, new Error(res.name));\n    }\n    \n    if (!ok) {\n        var e = new Error('exception');\n        var err = (e.stack || '').split('\\n');\n        var dir = path.dirname(__dirname) + '/';\n        \n        for (var i = 0; i < err.length; i++) {\n            var m = /^[^\\s]*\\s*\\bat\\s+(.+)/.exec(err[i]);\n            if (!m) {\n                continue;\n            }\n            \n            var s = m[1].split(/\\s+/);\n            var filem = /(\\/[^:\\s]+:(\\d+)(?::(\\d+))?)/.exec(s[1]);\n            if (!filem) {\n                filem = /(\\/[^:\\s]+:(\\d+)(?::(\\d+))?)/.exec(s[2]);\n                \n                if (!filem) {\n                    filem = /(\\/[^:\\s]+:(\\d+)(?::(\\d+))?)/.exec(s[3]);\n\n                    if (!filem) {\n                        continue;\n                    }\n                }\n            }\n            \n            if (filem[1].slice(0, dir.length) === dir) {\n                continue;\n            }\n            \n            res.functionName = s[0];\n            res.file = filem[1];\n            res.line = Number(filem[2]);\n            if (filem[3]) res.column = filem[3];\n            \n            res.at = m[1];\n            break;\n        }\n    }\n\n    self.emit('result', res);\n    \n    var pendingAsserts = self._pendingAsserts();\n    if (!pendingAsserts) {\n        if (extra.exiting) {\n            self._end();\n        } else {\n            nextTick(function () {\n                self._end();\n            });\n        }\n    }\n    \n    if (!self._planError && pendingAsserts < 0) {\n        self._planError = true;\n        self.fail('plan != count', {\n            expected : self._plan,\n            actual : self._plan - pendingAsserts\n        });\n    }\n};\n\nTest.prototype.fail = function (msg, extra) {\n    this._assert(false, {\n        message : msg,\n        operator : 'fail',\n        extra : extra\n    });\n};\n\nTest.prototype.pass = function (msg, extra) {\n    this._assert(true, {\n        message : msg,\n        operator : 'pass',\n        extra : extra\n    });\n};\n\nTest.prototype.skip = function (msg, extra) {\n    this._assert(true, {\n        message : msg,\n        operator : 'skip',\n        skip : true,\n        extra : extra\n    });\n};\n\nTest.prototype.ok\n= Test.prototype['true']\n= Test.prototype.assert\n= function (value, msg, extra) {\n    this._assert(value, {\n        message : msg,\n        operator : 'ok',\n        expected : true,\n        actual : value,\n        extra : extra\n    });\n};\n\nTest.prototype.notOk\n= Test.prototype['false']\n= Test.prototype.notok\n= function (value, msg, extra) {\n    this._assert(!value, {\n        message : msg,\n        operator : 'notOk',\n        expected : false,\n        actual : value,\n        extra : extra\n    });\n};\n\nTest.prototype.error\n= Test.prototype.ifError\n= Test.prototype.ifErr\n= Test.prototype.iferror\n= function (err, msg, extra) {\n    this._assert(!err, {\n        message : defined(msg, String(err)),\n        operator : 'error',\n        actual : err,\n        extra : extra\n    });\n};\n\nTest.prototype.equal\n= Test.prototype.equals\n= Test.prototype.isEqual\n= Test.prototype.is\n= Test.prototype.strictEqual\n= Test.prototype.strictEquals\n= function (a, b, msg, extra) {\n    this._assert(a === b, {\n        message : defined(msg, 'should be equal'),\n        operator : 'equal',\n        actual : a,\n        expected : b,\n        extra : extra\n    });\n};\n\nTest.prototype.notEqual\n= Test.prototype.notEquals\n= Test.prototype.notStrictEqual\n= Test.prototype.notStrictEquals\n= Test.prototype.isNotEqual\n= Test.prototype.isNot\n= Test.prototype.not\n= Test.prototype.doesNotEqual\n= Test.prototype.isInequal\n= function (a, b, msg, extra) {\n    this._assert(a !== b, {\n        message : defined(msg, 'should not be equal'),\n        operator : 'notEqual',\n        actual : a,\n        notExpected : b,\n        extra : extra\n    });\n};\n\nTest.prototype.deepEqual\n= Test.prototype.deepEquals\n= Test.prototype.isEquivalent\n= Test.prototype.same\n= function (a, b, msg, extra) {\n    this._assert(deepEqual(a, b, { strict: true }), {\n        message : defined(msg, 'should be equivalent'),\n        operator : 'deepEqual',\n        actual : a,\n        expected : b,\n        extra : extra\n    });\n};\n\nTest.prototype.deepLooseEqual\n= Test.prototype.looseEqual\n= Test.prototype.looseEquals\n= function (a, b, msg, extra) {\n    this._assert(deepEqual(a, b), {\n        message : defined(msg, 'should be equivalent'),\n        operator : 'deepLooseEqual',\n        actual : a,\n        expected : b,\n        extra : extra\n    });\n};\n\nTest.prototype.notDeepEqual\n= Test.prototype.notEquivalent\n= Test.prototype.notDeeply\n= Test.prototype.notSame\n= Test.prototype.isNotDeepEqual\n= Test.prototype.isNotDeeply\n= Test.prototype.isNotEquivalent\n= Test.prototype.isInequivalent\n= function (a, b, msg, extra) {\n    this._assert(!deepEqual(a, b, { strict: true }), {\n        message : defined(msg, 'should not be equivalent'),\n        operator : 'notDeepEqual',\n        actual : a,\n        notExpected : b,\n        extra : extra\n    });\n};\n\nTest.prototype.notDeepLooseEqual\n= Test.prototype.notLooseEqual\n= Test.prototype.notLooseEquals\n= function (a, b, msg, extra) {\n    this._assert(!deepEqual(a, b), {\n        message : defined(msg, 'should be equivalent'),\n        operator : 'notDeepLooseEqual',\n        actual : a,\n        expected : b,\n        extra : extra\n    });\n};\n\nTest.prototype['throws'] = function (fn, expected, msg, extra) {\n    if (typeof expected === 'string') {\n        msg = expected;\n        expected = undefined;\n    }\n\n    var caught = undefined;\n\n    try {\n        fn();\n    } catch (err) {\n        caught = { error : err };\n        var message = err.message;\n        delete err.message;\n        err.message = message;\n    }\n\n    var passed = caught;\n\n    if (expected instanceof RegExp) {\n        passed = expected.test(caught && caught.error);\n        expected = String(expected);\n    }\n\n    if (typeof expected === 'function' && caught) {\n        passed = caught.error instanceof expected;\n        caught.error = caught.error.constructor;\n    }\n\n    this._assert(passed, {\n        message : defined(msg, 'should throw'),\n        operator : 'throws',\n        actual : caught && caught.error,\n        expected : expected,\n        error: !passed && caught && caught.error,\n        extra : extra\n    });\n};\n\nTest.prototype.doesNotThrow = function (fn, expected, msg, extra) {\n    if (typeof expected === 'string') {\n        msg = expected;\n        expected = undefined;\n    }\n    var caught = undefined;\n    try {\n        fn();\n    }\n    catch (err) {\n        caught = { error : err };\n    }\n    this._assert(!caught, {\n        message : defined(msg, 'should not throw'),\n        operator : 'throws',\n        actual : caught && caught.error,\n        expected : expected,\n        error : caught && caught.error,\n        extra : extra\n    });\n};\n\nTest.skip = function (name_, _opts, _cb) {\n    var args = getTestArgs.apply(null, arguments);\n    args.opts.skip = true;\n    return Test(args.name, args.opts, args.cb);\n};\n\n// vim: set softtabstop=4 shiftwidth=4:\n\n","var pSlice = Array.prototype.slice;\nvar objectKeys = require('./lib/keys.js');\nvar isArguments = require('./lib/is_arguments.js');\n\nvar deepEqual = module.exports = function (actual, expected, opts) {\n  if (!opts) opts = {};\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n\n  } else if (actual instanceof Date && expected instanceof Date) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') {\n    return opts.strict ? actual === expected : actual == expected;\n\n  // 7.4. For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else {\n    return objEquiv(actual, expected, opts);\n  }\n}\n\nfunction isUndefinedOrNull(value) {\n  return value === null || value === undefined;\n}\n\nfunction isBuffer (x) {\n  if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false;\n  if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {\n    return false;\n  }\n  if (x.length > 0 && typeof x[0] !== 'number') return false;\n  return true;\n}\n\nfunction objEquiv(a, b, opts) {\n  var i, key;\n  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))\n    return false;\n  // an identical 'prototype' property.\n  if (a.prototype !== b.prototype) return false;\n  //~~~I've managed to break Object.keys through screwy arguments passing.\n  //   Converting to array solves the problem.\n  if (isArguments(a)) {\n    if (!isArguments(b)) {\n      return false;\n    }\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return deepEqual(a, b, opts);\n  }\n  if (isBuffer(a)) {\n    if (!isBuffer(b)) {\n      return false;\n    }\n    if (a.length !== b.length) return false;\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false;\n    }\n    return true;\n  }\n  try {\n    var ka = objectKeys(a),\n        kb = objectKeys(b);\n  } catch (e) {//happens when one is a string literal and the other isn't\n    return false;\n  }\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length != kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] != kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], opts)) return false;\n  }\n  return typeof a === typeof b;\n}\n","var supportsArgumentsClass = (function(){\n  return Object.prototype.toString.call(arguments)\n})() == '[object Arguments]';\n\nexports = module.exports = supportsArgumentsClass ? supported : unsupported;\n\nexports.supported = supported;\nfunction supported(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n};\n\nexports.unsupported = unsupported;\nfunction unsupported(object){\n  return object &&\n    typeof object == 'object' &&\n    typeof object.length == 'number' &&\n    Object.prototype.hasOwnProperty.call(object, 'callee') &&\n    !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||\n    false;\n};\n","exports = module.exports = typeof Object.keys === 'function'\n  ? Object.keys : shim;\n\nexports.shim = shim;\nfunction shim (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n","module.exports = function () {\n    for (var i = 0; i < arguments.length; i++) {\n        if (arguments[i] !== undefined) return arguments[i];\n    }\n};\n","var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    var bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n\n","var bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = function inspect_ (obj, opts, depth, seen) {\n    if (!opts) opts = {};\n    \n    var maxDepth = opts.depth === undefined ? 5 : opts.depth;\n    if (depth === undefined) depth = 0;\n    if (depth >= maxDepth && maxDepth > 0\n    && obj && typeof obj === 'object') {\n        return '[Object]';\n    }\n    \n    if (seen === undefined) seen = [];\n    else if (indexOf(seen, obj) >= 0) {\n        return '[Circular]';\n    }\n    \n    function inspect (value, from) {\n        if (from) {\n            seen = seen.slice();\n            seen.push(from);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n    }\n    \n    if (typeof obj === 'string') {\n        return inspectString(obj);\n    }\n    else if (typeof obj === 'function') {\n        var name = nameOf(obj);\n        return '[Function' + (name ? ': ' + name : '') + ']';\n    }\n    else if (obj === null) {\n        return 'null';\n    }\n    else if (isSymbol(obj)) {\n        var symString = Symbol.prototype.toString.call(obj);\n        return typeof obj === 'object' ? 'Object(' + symString + ')' : symString;\n    }\n    else if (isElement(obj)) {\n        var s = '<' + String(obj.nodeName).toLowerCase();\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n            s += ' ' + attrs[i].name + '=\"' + quote(attrs[i].value) + '\"';\n        }\n        s += '>';\n        if (obj.childNodes && obj.childNodes.length) s += '...';\n        s += '</' + String(obj.nodeName).toLowerCase() + '>';\n        return s;\n    }\n    else if (isArray(obj)) {\n        if (obj.length === 0) return '[]';\n        var xs = Array(obj.length);\n        for (var i = 0; i < obj.length; i++) {\n            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n        }\n        return '[ ' + xs.join(', ') + ' ]';\n    }\n    else if (isError(obj)) {\n        var parts = [];\n        for (var key in obj) {\n            if (!has(obj, key)) continue;\n            \n            if (/[^\\w$]/.test(key)) {\n                parts.push(inspect(key) + ': ' + inspect(obj[key]));\n            }\n            else {\n                parts.push(key + ': ' + inspect(obj[key]));\n            }\n        }\n        if (parts.length === 0) return '[' + obj + ']';\n        return '{ [' + obj + '] ' + parts.join(', ') + ' }';\n    }\n    else if (typeof obj === 'object' && typeof obj.inspect === 'function') {\n        return obj.inspect();\n    }\n    else if (typeof obj === 'object' && !isDate(obj) && !isRegExp(obj)) {\n        var xs = [], keys = [];\n        for (var key in obj) {\n            if (has(obj, key)) keys.push(key);\n        }\n        keys.sort();\n        for (var i = 0; i < keys.length; i++) {\n            var key = keys[i];\n            if (/[^\\w$]/.test(key)) {\n                xs.push(inspect(key) + ': ' + inspect(obj[key], obj));\n            }\n            else xs.push(key + ': ' + inspect(obj[key], obj));\n        }\n        if (xs.length === 0) return '{}';\n        return '{ ' + xs.join(', ') + ' }';\n    }\n    else return String(obj);\n};\n\nfunction quote (s) {\n    return String(s).replace(/\"/g, '&quot;');\n}\n\nfunction isArray (obj) { return toStr(obj) === '[object Array]' }\nfunction isDate (obj) { return toStr(obj) === '[object Date]' }\nfunction isRegExp (obj) { return toStr(obj) === '[object RegExp]' }\nfunction isError (obj) { return toStr(obj) === '[object Error]' }\nfunction isSymbol (obj) { return toStr(obj) === '[object Symbol]' }\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has (obj, key) {\n    return hasOwn.call(obj, key);\n}\n\nfunction toStr (obj) {\n    return Object.prototype.toString.call(obj);\n}\n\nfunction nameOf (f) {\n    if (f.name) return f.name;\n    var m = f.toString().match(/^function\\s*([\\w$]+)/);\n    if (m) return m[1];\n}\n\nfunction indexOf (xs, x) {\n    if (xs.indexOf) return xs.indexOf(x);\n    for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) return i;\n    }\n    return -1;\n}\n\nfunction isElement (x) {\n    if (!x || typeof x !== 'object') return false;\n    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n        return true;\n    }\n    return typeof x.nodeName === 'string'\n        && typeof x.getAttribute === 'function'\n    ;\n}\n\nfunction inspectString (str) {\n    var s = str.replace(/(['\\\\])/g, '\\\\$1').replace(/[\\x00-\\x1f]/g, lowbyte);\n    return \"'\" + s + \"'\";\n    \n    function lowbyte (c) {\n        var n = c.charCodeAt(0);\n        var x = { 8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r' }[n];\n        if (x) return '\\\\' + x;\n        return '\\\\x' + (n < 0x10 ? '0' : '') + n.toString(16);\n    }\n}\n","var through = require('through');\nvar nextTick = typeof setImmediate !== 'undefined'\n    ? setImmediate\n    : process.nextTick\n;\n\nmodule.exports = function (write, end) {\n    var tr = through(write, end);\n    tr.pause();\n    var resume = tr.resume;\n    var pause = tr.pause;\n    var paused = false;\n    \n    tr.pause = function () {\n        paused = true;\n        return pause.apply(this, arguments);\n    };\n    \n    tr.resume = function () {\n        paused = false;\n        return resume.apply(this, arguments);\n    };\n    \n    nextTick(function () {\n        if (!paused) tr.resume();\n    });\n    \n    return tr;\n};\n","var Stream = require('stream')\n\n// through\n//\n// a stream that does nothing but re-emit the input.\n// useful for aggregating a series of changing but not ending streams into one stream)\n\nexports = module.exports = through\nthrough.through = through\n\n//create a readable writable stream.\n\nfunction through (write, end, opts) {\n  write = write || function (data) { this.queue(data) }\n  end = end || function () { this.queue(null) }\n\n  var ended = false, destroyed = false, buffer = [], _ended = false\n  var stream = new Stream()\n  stream.readable = stream.writable = true\n  stream.paused = false\n\n//  stream.autoPause   = !(opts && opts.autoPause   === false)\n  stream.autoDestroy = !(opts && opts.autoDestroy === false)\n\n  stream.write = function (data) {\n    write.call(this, data)\n    return !stream.paused\n  }\n\n  function drain() {\n    while(buffer.length && !stream.paused) {\n      var data = buffer.shift()\n      if(null === data)\n        return stream.emit('end')\n      else\n        stream.emit('data', data)\n    }\n  }\n\n  stream.queue = stream.push = function (data) {\n//    console.error(ended)\n    if(_ended) return stream\n    if(data === null) _ended = true\n    buffer.push(data)\n    drain()\n    return stream\n  }\n\n  //this will be registered as the first 'end' listener\n  //must call destroy next tick, to make sure we're after any\n  //stream piped from here.\n  //this is only a problem if end is not emitted synchronously.\n  //a nicer way to do this is to make sure this is the last listener for 'end'\n\n  stream.on('end', function () {\n    stream.readable = false\n    if(!stream.writable && stream.autoDestroy)\n      process.nextTick(function () {\n        stream.destroy()\n      })\n  })\n\n  function _end () {\n    stream.writable = false\n    end.call(stream)\n    if(!stream.readable && stream.autoDestroy)\n      stream.destroy()\n  }\n\n  stream.end = function (data) {\n    if(ended) return\n    ended = true\n    if(arguments.length) stream.write(data)\n    _end() // will emit or queue\n    return stream\n  }\n\n  stream.destroy = function () {\n    if(destroyed) return\n    destroyed = true\n    ended = true\n    buffer.length = 0\n    stream.writable = stream.readable = false\n    stream.emit('close')\n    return stream\n  }\n\n  stream.pause = function () {\n    if(stream.paused) return\n    stream.paused = true\n    return stream\n  }\n\n  stream.resume = function () {\n    if(stream.paused) {\n      stream.paused = false\n      stream.emit('resume')\n    }\n    drain()\n    //may have become paused again,\n    //as drain emits 'data'.\n    if(!stream.paused)\n      stream.emit('drain')\n    return stream\n  }\n  return stream\n}\n\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n",null,"/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('is-array')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192 // not used by this implementation\n\nvar kMaxLength = 0x3fffffff\nvar rootParent = {}\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Note:\n *\n * - Implementation must support adding new properties to `Uint8Array` instances.\n *   Firefox 4-29 lacked support, fixed in Firefox 30+.\n *   See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *  - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *  - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *    incorrect length in some situations.\n *\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will\n * get the Object implementation, which is slower but will work correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = (function () {\n  try {\n    var buf = new ArrayBuffer(0)\n    var arr = new Uint8Array(buf)\n    arr.foo = function () { return 42 }\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n})()\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (arg) {\n  if (!(this instanceof Buffer)) {\n    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.\n    if (arguments.length > 1) return new Buffer(arg, arguments[1])\n    return new Buffer(arg)\n  }\n\n  this.length = 0\n  this.parent = undefined\n\n  // Common case.\n  if (typeof arg === 'number') {\n    return fromNumber(this, arg)\n  }\n\n  // Slightly less common case.\n  if (typeof arg === 'string') {\n    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')\n  }\n\n  // Unusual.\n  return fromObject(this, arg)\n}\n\nfunction fromNumber (that, length) {\n  that = allocate(that, length < 0 ? 0 : checked(length) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < length; i++) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'\n\n  // Assumption: byteLength() return value is always < kMaxLength.\n  var length = byteLength(string, encoding) | 0\n  that = allocate(that, length)\n\n  that.write(string, encoding)\n  return that\n}\n\nfunction fromObject (that, object) {\n  if (Buffer.isBuffer(object)) return fromBuffer(that, object)\n\n  if (isArray(object)) return fromArray(that, object)\n\n  if (object == null) {\n    throw new TypeError('must start with number, buffer, array or string')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && object.buffer instanceof ArrayBuffer) {\n    return fromTypedArray(that, object)\n  }\n\n  if (object.length) return fromArrayLike(that, object)\n\n  return fromJsonObject(that, object)\n}\n\nfunction fromBuffer (that, buffer) {\n  var length = checked(buffer.length) | 0\n  that = allocate(that, length)\n  buffer.copy(that, 0, 0, length)\n  return that\n}\n\nfunction fromArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Duplicate of fromArray() to keep fromArray() monomorphic.\nfunction fromTypedArray (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  // Truncating the elements is probably not what people expect from typed\n  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior\n  // of the old Buffer constructor.\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = checked(array.length) | 0\n  that = allocate(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\n// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.\n// Returns a zero-length buffer for inputs that don't conform to the spec.\nfunction fromJsonObject (that, object) {\n  var array\n  var length = 0\n\n  if (object.type === 'Buffer' && isArray(object.data)) {\n    array = object.data\n    length = checked(array.length) | 0\n  }\n  that = allocate(that, length)\n\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction allocate (that, length) {\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = Buffer._augment(new Uint8Array(length))\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that.length = length\n    that._isBuffer = true\n  }\n\n  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1\n  if (fromPool) that.parent = rootParent\n\n  return that\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (subject, encoding) {\n  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)\n\n  var buf = new Buffer(subject, encoding)\n  delete buf.parent\n  return buf\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  var i = 0\n  var len = Math.min(x, y)\n  while (i < len) {\n    if (a[i] !== b[i]) break\n\n    ++i\n  }\n\n  if (i !== len) {\n    x = a[i]\n    y = b[i]\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  } else if (list.length === 1) {\n    return list[0]\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; i++) {\n      length += list[i].length\n    }\n  }\n\n  var buf = new Buffer(length)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\nfunction byteLength (string, encoding) {\n  if (typeof string !== 'string') string = String(string)\n\n  if (string.length === 0) return 0\n\n  switch (encoding || 'utf8') {\n    case 'ascii':\n    case 'binary':\n    case 'raw':\n      return string.length\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return string.length * 2\n    case 'hex':\n      return string.length >>> 1\n    case 'utf8':\n    case 'utf-8':\n      return utf8ToBytes(string).length\n    case 'base64':\n      return base64ToBytes(string).length\n    default:\n      return string.length\n  }\n}\nBuffer.byteLength = byteLength\n\n// pre-set for values that may exist in the future\nBuffer.prototype.length = undefined\nBuffer.prototype.parent = undefined\n\n// toString(encoding, start=0, end=buffer.length)\nBuffer.prototype.toString = function toString (encoding, start, end) {\n  var loweredCase = false\n\n  start = start | 0\n  end = end === undefined || end === Infinity ? this.length : end | 0\n\n  if (!encoding) encoding = 'utf8'\n  if (start < 0) start = 0\n  if (end > this.length) end = this.length\n  if (end <= start) return ''\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'binary':\n        return binarySlice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return 0\n  return Buffer.compare(this, b)\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset) {\n  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff\n  else if (byteOffset < -0x80000000) byteOffset = -0x80000000\n  byteOffset >>= 0\n\n  if (this.length === 0) return -1\n  if (byteOffset >= this.length) return -1\n\n  // Negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)\n\n  if (typeof val === 'string') {\n    if (val.length === 0) return -1 // special case: looking for empty string always fails\n    return String.prototype.indexOf.call(this, val, byteOffset)\n  }\n  if (Buffer.isBuffer(val)) {\n    return arrayIndexOf(this, val, byteOffset)\n  }\n  if (typeof val === 'number') {\n    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {\n      return Uint8Array.prototype.indexOf.call(this, val, byteOffset)\n    }\n    return arrayIndexOf(this, [ val ], byteOffset)\n  }\n\n  function arrayIndexOf (arr, val, byteOffset) {\n    var foundIndex = -1\n    for (var i = 0; byteOffset + i < arr.length; i++) {\n      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex\n      } else {\n        foundIndex = -1\n      }\n    }\n    return -1\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\n// `get` will be removed in Node 0.13+\nBuffer.prototype.get = function get (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` will be removed in Node 0.13+\nBuffer.prototype.set = function set (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new Error('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) throw new Error('Invalid hex string')\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction binaryWrite (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    var swap = encoding\n    encoding = offset\n    offset = length | 0\n    length = swap\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'binary':\n        return binaryWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  var res = ''\n  var tmp = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    if (buf[i] <= 0x7F) {\n      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])\n      tmp = ''\n    } else {\n      tmp += '%' + buf[i].toString(16)\n    }\n  }\n\n  return res + decodeUtf8Char(tmp)\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction binarySlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  if (newBuf.length) newBuf.parent = this.parent || this\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = value\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = value\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = value\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = value\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = value < 0 ? 1 : 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = value\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = value\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = value\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = value\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (value > max || value < min) throw new RangeError('value is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('index out of range')\n  if (offset < 0) throw new RangeError('index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n\n  if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < len; i++) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    target._set(this.subarray(start, start + len), targetStart)\n  }\n\n  return len\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function fill (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (end < start) throw new RangeError('end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')\n  if (end < 0 || end > this.length) throw new RangeError('end out of bounds')\n\n  var i\n  if (typeof value === 'number') {\n    for (i = start; i < end; i++) {\n      this[i] = value\n    }\n  } else {\n    var bytes = utf8ToBytes(value.toString())\n    var len = bytes.length\n    for (i = start; i < end; i++) {\n      this[i] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function toArrayBuffer () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer.TYPED_ARRAY_SUPPORT) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1) {\n        buf[i] = this[i]\n      }\n      return buf.buffer\n    }\n  } else {\n    throw new TypeError('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function _augment (arr) {\n  arr.constructor = Buffer\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array set method before overwriting\n  arr._set = arr.set\n\n  // deprecated, will be removed in node 0.13+\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.equals = BP.equals\n  arr.compare = BP.compare\n  arr.indexOf = BP.indexOf\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUIntLE = BP.readUIntLE\n  arr.readUIntBE = BP.readUIntBE\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readIntLE = BP.readIntLE\n  arr.readIntBE = BP.readIntBE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUIntLE = BP.writeUIntLE\n  arr.writeUIntBE = BP.writeUIntBE\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeIntLE = BP.writeIntLE\n  arr.writeIntBE = BP.writeIntBE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-z\\-]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n  var i = 0\n\n  for (; i < length; i++) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (leadSurrogate) {\n        // 2 leads in a row\n        if (codePoint < 0xDC00) {\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          leadSurrogate = codePoint\n          continue\n        } else {\n          // valid surrogate pair\n          codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000\n          leadSurrogate = null\n        }\n      } else {\n        // no lead yet\n\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else {\n          // valid lead\n          leadSurrogate = codePoint\n          continue\n        }\n      }\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n      leadSurrogate = null\n    }\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x200000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction decodeUtf8Char (str) {\n  try {\n    return decodeURIComponent(str)\n  } catch (err) {\n    return String.fromCharCode(0xFFFD) // UTF 8 invalid char\n  }\n}\n","var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n;(function (exports) {\n\t'use strict';\n\n  var Arr = (typeof Uint8Array !== 'undefined')\n    ? Uint8Array\n    : Array\n\n\tvar PLUS   = '+'.charCodeAt(0)\n\tvar SLASH  = '/'.charCodeAt(0)\n\tvar NUMBER = '0'.charCodeAt(0)\n\tvar LOWER  = 'a'.charCodeAt(0)\n\tvar UPPER  = 'A'.charCodeAt(0)\n\tvar PLUS_URL_SAFE = '-'.charCodeAt(0)\n\tvar SLASH_URL_SAFE = '_'.charCodeAt(0)\n\n\tfunction decode (elt) {\n\t\tvar code = elt.charCodeAt(0)\n\t\tif (code === PLUS ||\n\t\t    code === PLUS_URL_SAFE)\n\t\t\treturn 62 // '+'\n\t\tif (code === SLASH ||\n\t\t    code === SLASH_URL_SAFE)\n\t\t\treturn 63 // '/'\n\t\tif (code < NUMBER)\n\t\t\treturn -1 //no match\n\t\tif (code < NUMBER + 10)\n\t\t\treturn code - NUMBER + 26 + 26\n\t\tif (code < UPPER + 26)\n\t\t\treturn code - UPPER\n\t\tif (code < LOWER + 26)\n\t\t\treturn code - LOWER + 26\n\t}\n\n\tfunction b64ToByteArray (b64) {\n\t\tvar i, j, l, tmp, placeHolders, arr\n\n\t\tif (b64.length % 4 > 0) {\n\t\t\tthrow new Error('Invalid string. Length must be a multiple of 4')\n\t\t}\n\n\t\t// the number of equal signs (place holders)\n\t\t// if there are two placeholders, than the two characters before it\n\t\t// represent one byte\n\t\t// if there is only one, then the three characters before it represent 2 bytes\n\t\t// this is just a cheap hack to not do indexOf twice\n\t\tvar len = b64.length\n\t\tplaceHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0\n\n\t\t// base64 is 4/3 + up to two characters of the original data\n\t\tarr = new Arr(b64.length * 3 / 4 - placeHolders)\n\n\t\t// if there are placeholders, only get up to the last complete 4 chars\n\t\tl = placeHolders > 0 ? b64.length - 4 : b64.length\n\n\t\tvar L = 0\n\n\t\tfunction push (v) {\n\t\t\tarr[L++] = v\n\t\t}\n\n\t\tfor (i = 0, j = 0; i < l; i += 4, j += 3) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))\n\t\t\tpush((tmp & 0xFF0000) >> 16)\n\t\t\tpush((tmp & 0xFF00) >> 8)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\tif (placeHolders === 2) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)\n\t\t\tpush(tmp & 0xFF)\n\t\t} else if (placeHolders === 1) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)\n\t\t\tpush((tmp >> 8) & 0xFF)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\treturn arr\n\t}\n\n\tfunction uint8ToBase64 (uint8) {\n\t\tvar i,\n\t\t\textraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes\n\t\t\toutput = \"\",\n\t\t\ttemp, length\n\n\t\tfunction encode (num) {\n\t\t\treturn lookup.charAt(num)\n\t\t}\n\n\t\tfunction tripletToBase64 (num) {\n\t\t\treturn encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)\n\t\t}\n\n\t\t// go through the array every three bytes, we'll deal with trailing stuff later\n\t\tfor (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {\n\t\t\ttemp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n\t\t\toutput += tripletToBase64(temp)\n\t\t}\n\n\t\t// pad the end with zeros, but make sure to not forget the extra bytes\n\t\tswitch (extraBytes) {\n\t\t\tcase 1:\n\t\t\t\ttemp = uint8[uint8.length - 1]\n\t\t\t\toutput += encode(temp >> 2)\n\t\t\t\toutput += encode((temp << 4) & 0x3F)\n\t\t\t\toutput += '=='\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\ttemp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])\n\t\t\t\toutput += encode(temp >> 10)\n\t\t\t\toutput += encode((temp >> 4) & 0x3F)\n\t\t\t\toutput += encode((temp << 2) & 0x3F)\n\t\t\t\toutput += '='\n\t\t\t\tbreak\n\t\t}\n\n\t\treturn output\n\t}\n\n\texports.toByteArray = b64ToByteArray\n\texports.fromByteArray = uint8ToBase64\n}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = nBytes * 8 - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","\n/**\n * isArray\n */\n\nvar isArray = Array.isArray;\n\n/**\n * toString\n */\n\nvar str = Object.prototype.toString;\n\n/**\n * Whether or not the given `val`\n * is an array.\n *\n * example:\n *\n *        isArray([]);\n *        // > true\n *        isArray(arguments);\n *        // > false\n *        isArray('');\n *        // > false\n *\n * @param {mixed} val\n * @return {bool}\n */\n\nmodule.exports = isArray || function (val) {\n  return !! val && '[object Array]' == str.call(val);\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      }\n      throw TypeError('Uncaught, unspecified \"error\" event.');\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        len = arguments.length;\n        args = new Array(len - 1);\n        for (i = 1; i < len; i++)\n          args[i - 1] = arguments[i];\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    len = arguments.length;\n    args = new Array(len - 1);\n    for (i = 1; i < len; i++)\n      args[i - 1] = arguments[i];\n\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    var m;\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  var ret;\n  if (!emitter._events || !emitter._events[type])\n    ret = 0;\n  else if (isFunction(emitter._events[type]))\n    ret = 1;\n  else\n    ret = emitter._events[type].length;\n  return ret;\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar splitPath = function(filename) {\n  return splitPathRe.exec(filename).slice(1);\n};\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nexports.basename = function(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nexports.extname = function(path) {\n  return splitPath(path)[3];\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = setTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            currentQueue[queueIndex].run();\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        setTimeout(drainQueue, 0);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","module.exports = require(\"./lib/_stream_duplex.js\")\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n/*</replacement>*/\n\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\nforEach(objectKeys(Writable.prototype), function(method) {\n  if (!Duplex.prototype[method])\n    Duplex.prototype[method] = Writable.prototype[method];\n});\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex))\n    return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false)\n    this.readable = false;\n\n  if (options && options.writable === false)\n    this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false)\n    this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended)\n    return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(this.end.bind(this));\n}\n\nfunction forEach (xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough))\n    return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function(chunk, encoding, cb) {\n  cb(null, chunk);\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n\n/*<replacement>*/\nvar Buffer = require('buffer').Buffer;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\nvar EE = require('events').EventEmitter;\n\n/*<replacement>*/\nif (!EE.listenerCount) EE.listenerCount = function(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\nvar Stream = require('stream');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar StringDecoder;\n\n\n/*<replacement>*/\nvar debug = require('util');\nif (debug && debug.debuglog) {\n  debug = debug.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\n\nutil.inherits(Readable, Stream);\n\nfunction ReadableState(options, stream) {\n  var Duplex = require('./_stream_duplex');\n\n  options = options || {};\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var defaultHwm = options.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.buffer = [];\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex)\n    this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // when piping, we only care about 'readable' events that happen\n  // after read()ing all the bytes and not getting any pushback.\n  this.ranOut = false;\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder)\n      StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  var Duplex = require('./_stream_duplex');\n\n  if (!(this instanceof Readable))\n    return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  Stream.call(this);\n}\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function(chunk, encoding) {\n  var state = this._readableState;\n\n  if (util.isString(chunk) && !state.objectMode) {\n    encoding = encoding || state.defaultEncoding;\n    if (encoding !== state.encoding) {\n      chunk = new Buffer(chunk, encoding);\n      encoding = '';\n    }\n  }\n\n  return readableAddChunk(this, state, chunk, encoding, false);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function(chunk) {\n  var state = this._readableState;\n  return readableAddChunk(this, state, chunk, '', true);\n};\n\nfunction readableAddChunk(stream, state, chunk, encoding, addToFront) {\n  var er = chunkInvalid(state, chunk);\n  if (er) {\n    stream.emit('error', er);\n  } else if (util.isNullOrUndefined(chunk)) {\n    state.reading = false;\n    if (!state.ended)\n      onEofChunk(stream, state);\n  } else if (state.objectMode || chunk && chunk.length > 0) {\n    if (state.ended && !addToFront) {\n      var e = new Error('stream.push() after EOF');\n      stream.emit('error', e);\n    } else if (state.endEmitted && addToFront) {\n      var e = new Error('stream.unshift() after end event');\n      stream.emit('error', e);\n    } else {\n      if (state.decoder && !addToFront && !encoding)\n        chunk = state.decoder.write(chunk);\n\n      if (!addToFront)\n        state.reading = false;\n\n      // if we want the data now, just emit it.\n      if (state.flowing && state.length === 0 && !state.sync) {\n        stream.emit('data', chunk);\n        stream.read(0);\n      } else {\n        // update the buffer info.\n        state.length += state.objectMode ? 1 : chunk.length;\n        if (addToFront)\n          state.buffer.unshift(chunk);\n        else\n          state.buffer.push(chunk);\n\n        if (state.needReadable)\n          emitReadable(stream);\n      }\n\n      maybeReadMore(stream, state);\n    }\n  } else if (!addToFront) {\n    state.reading = false;\n  }\n\n  return needMoreData(state);\n}\n\n\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended &&\n         (state.needReadable ||\n          state.length < state.highWaterMark ||\n          state.length === 0);\n}\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function(enc) {\n  if (!StringDecoder)\n    StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 128MB\nvar MAX_HWM = 0x800000;\nfunction roundUpToNextPowerOf2(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2\n    n--;\n    for (var p = 1; p < 32; p <<= 1) n |= n >> p;\n    n++;\n  }\n  return n;\n}\n\nfunction howMuchToRead(n, state) {\n  if (state.length === 0 && state.ended)\n    return 0;\n\n  if (state.objectMode)\n    return n === 0 ? 0 : 1;\n\n  if (isNaN(n) || util.isNull(n)) {\n    // only flow one buffer at a time\n    if (state.flowing && state.buffer.length)\n      return state.buffer[0].length;\n    else\n      return state.length;\n  }\n\n  if (n <= 0)\n    return 0;\n\n  // If we're asking for more than the target buffer level,\n  // then raise the water mark.  Bump up to the next highest\n  // power of 2, to prevent increasing it excessively in tiny\n  // amounts.\n  if (n > state.highWaterMark)\n    state.highWaterMark = roundUpToNextPowerOf2(n);\n\n  // don't have that much.  return null, unless we've ended.\n  if (n > state.length) {\n    if (!state.ended) {\n      state.needReadable = true;\n      return 0;\n    } else\n      return state.length;\n  }\n\n  return n;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function(n) {\n  debug('read', n);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (!util.isNumber(n) || n > 0)\n    state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 &&\n      state.needReadable &&\n      (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended)\n      endReadable(this);\n    else\n      emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0)\n      endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  }\n\n  if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0)\n      state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n  }\n\n  // If _read pushed data synchronously, then `reading` will be false,\n  // and we need to re-evaluate how much data we can return to the user.\n  if (doRead && !state.reading)\n    n = howMuchToRead(nOrig, state);\n\n  var ret;\n  if (n > 0)\n    ret = fromList(n, state);\n  else\n    ret = null;\n\n  if (util.isNull(ret)) {\n    state.needReadable = true;\n    n = 0;\n  }\n\n  state.length -= n;\n\n  // If we have nothing in the buffer, then we want to know\n  // as soon as we *do* get something into the buffer.\n  if (state.length === 0 && !state.ended)\n    state.needReadable = true;\n\n  // If we tried to read() past the EOF, then emit end on the next tick.\n  if (nOrig !== n && state.ended && state.length === 0)\n    endReadable(this);\n\n  if (!util.isNull(ret))\n    this.emit('data', ret);\n\n  return ret;\n};\n\nfunction chunkInvalid(state, chunk) {\n  var er = null;\n  if (!util.isBuffer(chunk) &&\n      !util.isString(chunk) &&\n      !util.isNullOrUndefined(chunk) &&\n      !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n\nfunction onEofChunk(stream, state) {\n  if (state.decoder && !state.ended) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync)\n      process.nextTick(function() {\n        emitReadable_(stream);\n      });\n    else\n      emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(function() {\n      maybeReadMore_(stream, state);\n    });\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended &&\n         state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n    else\n      len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function(n) {\n  this.emit('error', new Error('not implemented'));\n};\n\nReadable.prototype.pipe = function(dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&\n              dest !== process.stdout &&\n              dest !== process.stderr;\n\n  var endFn = doEnd ? onend : cleanup;\n  if (state.endEmitted)\n    process.nextTick(endFn);\n  else\n    src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable) {\n    debug('onunpipe');\n    if (readable === src) {\n      cleanup();\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', cleanup);\n    src.removeListener('data', ondata);\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain &&\n        (!dest._writableState || dest._writableState.needDrain))\n      ondrain();\n  }\n\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    if (false === ret) {\n      debug('false write response, pause',\n            src._readableState.awaitDrain);\n      src._readableState.awaitDrain++;\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EE.listenerCount(dest, 'error') === 0)\n      dest.emit('error', er);\n  }\n  // This is a brutally ugly hack to make sure that our error handler\n  // is attached before any userland ones.  NEVER DO THIS.\n  if (!dest._events || !dest._events.error)\n    dest.on('error', onerror);\n  else if (isArray(dest._events.error))\n    dest._events.error.unshift(onerror);\n  else\n    dest._events.error = [onerror, dest._events.error];\n\n\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain)\n      state.awaitDrain--;\n    if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\n\nReadable.prototype.unpipe = function(dest) {\n  var state = this._readableState;\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0)\n    return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes)\n      return this;\n\n    if (!dest)\n      dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest)\n      dest.emit('unpipe', this);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++)\n      dests[i].emit('unpipe', this);\n    return this;\n  }\n\n  // try to find the right one.\n  var i = indexOf(state.pipes, dest);\n  if (i === -1)\n    return this;\n\n  state.pipes.splice(i, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1)\n    state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function(ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  // If listening to data, and it has not explicitly been paused,\n  // then call resume to start the flow of data on the next tick.\n  if (ev === 'data' && false !== this._readableState.flowing) {\n    this.resume();\n  }\n\n  if (ev === 'readable' && this.readable) {\n    var state = this._readableState;\n    if (!state.readableListening) {\n      state.readableListening = true;\n      state.emittedReadable = false;\n      state.needReadable = true;\n      if (!state.reading) {\n        var self = this;\n        process.nextTick(function() {\n          debug('readable nexttick read 0');\n          self.read(0);\n        });\n      } else if (state.length) {\n        emitReadable(this, state);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function() {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    if (!state.reading) {\n      debug('resume read 0');\n      this.read(0);\n    }\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(function() {\n      resume_(stream, state);\n    });\n  }\n}\n\nfunction resume_(stream, state) {\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading)\n    stream.read(0);\n}\n\nReadable.prototype.pause = function() {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  if (state.flowing) {\n    do {\n      var chunk = stream.read();\n    } while (null !== chunk && state.flowing);\n  }\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function(stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function() {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length)\n        self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function(chunk) {\n    debug('wrapped data');\n    if (state.decoder)\n      chunk = state.decoder.write(chunk);\n    if (!chunk || !state.objectMode && !chunk.length)\n      return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (util.isFunction(stream[i]) && util.isUndefined(this[i])) {\n      this[i] = function(method) { return function() {\n        return stream[method].apply(stream, arguments);\n      }}(i);\n    }\n  }\n\n  // proxy certain important events.\n  var events = ['error', 'close', 'destroy', 'pause', 'resume'];\n  forEach(events, function(ev) {\n    stream.on(ev, self.emit.bind(self, ev));\n  });\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function(n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\nfunction fromList(n, state) {\n  var list = state.buffer;\n  var length = state.length;\n  var stringMode = !!state.decoder;\n  var objectMode = !!state.objectMode;\n  var ret;\n\n  // nothing in the list, definitely empty.\n  if (list.length === 0)\n    return null;\n\n  if (length === 0)\n    ret = null;\n  else if (objectMode)\n    ret = list.shift();\n  else if (!n || n >= length) {\n    // read it all, truncate the array.\n    if (stringMode)\n      ret = list.join('');\n    else\n      ret = Buffer.concat(list, length);\n    list.length = 0;\n  } else {\n    // read just some of it.\n    if (n < list[0].length) {\n      // just take a part of the first list item.\n      // slice is the same for buffers and strings.\n      var buf = list[0];\n      ret = buf.slice(0, n);\n      list[0] = buf.slice(n);\n    } else if (n === list[0].length) {\n      // first list is a perfect match\n      ret = list.shift();\n    } else {\n      // complex case.\n      // we have enough to cover it, but it spans past the first buffer.\n      if (stringMode)\n        ret = '';\n      else\n        ret = new Buffer(n);\n\n      var c = 0;\n      for (var i = 0, l = list.length; i < l && c < n; i++) {\n        var buf = list[0];\n        var cpy = Math.min(n - c, buf.length);\n\n        if (stringMode)\n          ret += buf.slice(0, cpy);\n        else\n          buf.copy(ret, c, 0, cpy);\n\n        if (cpy < buf.length)\n          list[0] = buf.slice(cpy);\n        else\n          list.shift();\n\n        c += cpy;\n      }\n    }\n  }\n\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0)\n    throw new Error('endReadable called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(function() {\n      // Check that we didn't get one last unshift.\n      if (!state.endEmitted && state.length === 0) {\n        state.endEmitted = true;\n        stream.readable = false;\n        stream.emit('end');\n      }\n    });\n  }\n}\n\nfunction forEach (xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf (xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\n\nfunction TransformState(options, stream) {\n  this.afterTransform = function(er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb)\n    return stream.emit('error', new Error('no writecb in Transform class'));\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (!util.isNullOrUndefined(data))\n    stream.push(data);\n\n  if (cb)\n    cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\n\nfunction Transform(options) {\n  if (!(this instanceof Transform))\n    return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = new TransformState(options, this);\n\n  // when the writable side finishes, then flush out anything remaining.\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  this.once('prefinish', function() {\n    if (util.isFunction(this._flush))\n      this._flush(function(er) {\n        done(stream, er);\n      });\n    else\n      done(stream);\n  });\n}\n\nTransform.prototype.push = function(chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function(chunk, encoding, cb) {\n  throw new Error('not implemented');\n};\n\nTransform.prototype._write = function(chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform ||\n        rs.needReadable ||\n        rs.length < rs.highWaterMark)\n      this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function(n) {\n  var ts = this._transformState;\n\n  if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\n\nfunction done(stream, er) {\n  if (er)\n    return stream.emit('error', er);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var ts = stream._transformState;\n\n  if (ws.length)\n    throw new Error('calling transform done when ws.length != 0');\n\n  if (ts.transforming)\n    throw new Error('calling transform done when still transforming');\n\n  return stream.push(null);\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, cb), and it'll handle all\n// the drain event emission and buffering.\n\nmodule.exports = Writable;\n\n/*<replacement>*/\nvar Buffer = require('buffer').Buffer;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Stream = require('stream');\n\nutil.inherits(Writable, Stream);\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n}\n\nfunction WritableState(options, stream) {\n  var Duplex = require('./_stream_duplex');\n\n  options = options || {};\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var defaultHwm = options.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex)\n    this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function(er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.buffer = [];\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n}\n\nfunction Writable(options) {\n  var Duplex = require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, though they're not\n  // instanceof Writable, they're instanceof Readable.\n  if (!(this instanceof Writable) && !(this instanceof Duplex))\n    return new Writable(options);\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function() {\n  this.emit('error', new Error('Cannot pipe. Not readable.'));\n};\n\n\nfunction writeAfterEnd(stream, state, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  process.nextTick(function() {\n    cb(er);\n  });\n}\n\n// If we get something that is not a buffer, string, null, or undefined,\n// and we're not in objectMode, then that's an error.\n// Otherwise stream chunks are all considered to be of length=1, and the\n// watermarks determine how many objects to keep in the buffer, rather than\n// how many bytes or characters.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  if (!util.isBuffer(chunk) &&\n      !util.isString(chunk) &&\n      !util.isNullOrUndefined(chunk) &&\n      !state.objectMode) {\n    var er = new TypeError('Invalid non-string/buffer chunk');\n    stream.emit('error', er);\n    process.nextTick(function() {\n      cb(er);\n    });\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function(chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  if (util.isFunction(encoding)) {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (util.isBuffer(chunk))\n    encoding = 'buffer';\n  else if (!encoding)\n    encoding = state.defaultEncoding;\n\n  if (!util.isFunction(cb))\n    cb = function() {};\n\n  if (state.ended)\n    writeAfterEnd(this, state, cb);\n  else if (validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function() {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function() {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing &&\n        !state.corked &&\n        !state.finished &&\n        !state.bufferProcessing &&\n        state.buffer.length)\n      clearBuffer(this, state);\n  }\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode &&\n      state.decodeStrings !== false &&\n      util.isString(chunk)) {\n    chunk = new Buffer(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, chunk, encoding, cb) {\n  chunk = decodeChunk(state, chunk, encoding);\n  if (util.isBuffer(chunk))\n    encoding = 'buffer';\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret)\n    state.needDrain = true;\n\n  if (state.writing || state.corked)\n    state.buffer.push(new WriteReq(chunk, encoding, cb));\n  else\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev)\n    stream._writev(chunk, state.onwrite);\n  else\n    stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  if (sync)\n    process.nextTick(function() {\n      state.pendingcb--;\n      cb(er);\n    });\n  else {\n    state.pendingcb--;\n    cb(er);\n  }\n\n  stream._writableState.errorEmitted = true;\n  stream.emit('error', er);\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er)\n    onwriteError(stream, state, sync, er, cb);\n  else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(stream, state);\n\n    if (!finished &&\n        !state.corked &&\n        !state.bufferProcessing &&\n        state.buffer.length) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(function() {\n        afterWrite(stream, state, finished, cb);\n      });\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished)\n    onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n\n  if (stream._writev && state.buffer.length > 1) {\n    // Fast case, write everything using _writev()\n    var cbs = [];\n    for (var c = 0; c < state.buffer.length; c++)\n      cbs.push(state.buffer[c].callback);\n\n    // count the one we are adding, as well.\n    // TODO(isaacs) clean this up\n    state.pendingcb++;\n    doWrite(stream, state, true, state.length, state.buffer, '', function(err) {\n      for (var i = 0; i < cbs.length; i++) {\n        state.pendingcb--;\n        cbs[i](err);\n      }\n    });\n\n    // Clear buffer\n    state.buffer = [];\n  } else {\n    // Slow case, write chunks one-by-one\n    for (var c = 0; c < state.buffer.length; c++) {\n      var entry = state.buffer[c];\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        c++;\n        break;\n      }\n    }\n\n    if (c < state.buffer.length)\n      state.buffer = state.buffer.slice(c);\n    else\n      state.buffer.length = 0;\n  }\n\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function(chunk, encoding, cb) {\n  cb(new Error('not implemented'));\n\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function(chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (util.isFunction(chunk)) {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (util.isFunction(encoding)) {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (!util.isNullOrUndefined(chunk))\n    this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished)\n    endWritable(this, state, cb);\n};\n\n\nfunction needFinish(stream, state) {\n  return (state.ending &&\n          state.length === 0 &&\n          !state.finished &&\n          !state.writing);\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished) {\n    state.prefinished = true;\n    stream.emit('prefinish');\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(stream, state);\n  if (need) {\n    if (state.pendingcb === 0) {\n      prefinish(stream, state);\n      state.finished = true;\n      stream.emit('finish');\n    } else\n      prefinish(stream, state);\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished)\n      process.nextTick(cb);\n    else\n      stream.once('finish', cb);\n  }\n  state.ended = true;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nfunction isBuffer(arg) {\n  return Buffer.isBuffer(arg);\n}\nexports.isBuffer = isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}","module.exports = require(\"./lib/_stream_passthrough.js\")\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = require('stream');\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","module.exports = require(\"./lib/_stream_transform.js\")\n","module.exports = require(\"./lib/_stream_writable.js\")\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar Buffer = require('buffer').Buffer;\n\nvar isBufferEncoding = Buffer.isEncoding\n  || function(encoding) {\n       switch (encoding && encoding.toLowerCase()) {\n         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;\n         default: return false;\n       }\n     }\n\n\nfunction assertEncoding(encoding) {\n  if (encoding && !isBufferEncoding(encoding)) {\n    throw new Error('Unknown encoding: ' + encoding);\n  }\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\n//\n// @TODO Handling all encodings inside a single object makes it very difficult\n// to reason about this code, so it should be split up in the future.\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\n// points as used by CESU-8.\nvar StringDecoder = exports.StringDecoder = function(encoding) {\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\n  assertEncoding(encoding);\n  switch (this.encoding) {\n    case 'utf8':\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\n      this.surrogateSize = 3;\n      break;\n    case 'ucs2':\n    case 'utf16le':\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\n      this.surrogateSize = 2;\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\n      break;\n    case 'base64':\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\n      this.surrogateSize = 3;\n      this.detectIncompleteChar = base64DetectIncompleteChar;\n      break;\n    default:\n      this.write = passThroughWrite;\n      return;\n  }\n\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\n  this.charBuffer = new Buffer(6);\n  // Number of bytes received for the current incomplete multi-byte character.\n  this.charReceived = 0;\n  // Number of bytes expected for the current incomplete multi-byte character.\n  this.charLength = 0;\n};\n\n\n// write decodes the given buffer and returns it as JS string that is\n// guaranteed to not contain any partial multi-byte characters. Any partial\n// character found at the end of the buffer is buffered up, and will be\n// returned when calling write again with the remaining bytes.\n//\n// Note: Converting a Buffer containing an orphan surrogate to a String\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\n// Buffer#write) will replace incomplete surrogates with the unicode\n// replacement character. See https://codereview.chromium.org/121173009/ .\nStringDecoder.prototype.write = function(buffer) {\n  var charStr = '';\n  // if our last write ended with an incomplete multibyte character\n  while (this.charLength) {\n    // determine how many remaining bytes this buffer has to offer for this char\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\n        this.charLength - this.charReceived :\n        buffer.length;\n\n    // add the new bytes to the char buffer\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\n    this.charReceived += available;\n\n    if (this.charReceived < this.charLength) {\n      // still not enough chars in this buffer? wait for more ...\n      return '';\n    }\n\n    // remove bytes belonging to the current character from the buffer\n    buffer = buffer.slice(available, buffer.length);\n\n    // get the character that was split\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\n\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n    var charCode = charStr.charCodeAt(charStr.length - 1);\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n      this.charLength += this.surrogateSize;\n      charStr = '';\n      continue;\n    }\n    this.charReceived = this.charLength = 0;\n\n    // if there are no more bytes in this buffer, just emit our char\n    if (buffer.length === 0) {\n      return charStr;\n    }\n    break;\n  }\n\n  // determine and set charLength / charReceived\n  this.detectIncompleteChar(buffer);\n\n  var end = buffer.length;\n  if (this.charLength) {\n    // buffer the incomplete character bytes we got\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\n    end -= this.charReceived;\n  }\n\n  charStr += buffer.toString(this.encoding, 0, end);\n\n  var end = charStr.length - 1;\n  var charCode = charStr.charCodeAt(end);\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\n    var size = this.surrogateSize;\n    this.charLength += size;\n    this.charReceived += size;\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\n    buffer.copy(this.charBuffer, 0, 0, size);\n    return charStr.substring(0, end);\n  }\n\n  // or just emit the charStr\n  return charStr;\n};\n\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\n// the end of the given buffer. If so, it sets this.charLength to the byte\n// length that character, and sets this.charReceived to the number of bytes\n// that are available for this character.\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\n  // determine how many bytes we have to check at the end of this buffer\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\n\n  // Figure out if one of the last i bytes of our buffer announces an\n  // incomplete char.\n  for (; i > 0; i--) {\n    var c = buffer[buffer.length - i];\n\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\n\n    // 110XXXXX\n    if (i == 1 && c >> 5 == 0x06) {\n      this.charLength = 2;\n      break;\n    }\n\n    // 1110XXXX\n    if (i <= 2 && c >> 4 == 0x0E) {\n      this.charLength = 3;\n      break;\n    }\n\n    // 11110XXX\n    if (i <= 3 && c >> 3 == 0x1E) {\n      this.charLength = 4;\n      break;\n    }\n  }\n  this.charReceived = i;\n};\n\nStringDecoder.prototype.end = function(buffer) {\n  var res = '';\n  if (buffer && buffer.length)\n    res = this.write(buffer);\n\n  if (this.charReceived) {\n    var cr = this.charReceived;\n    var buf = this.charBuffer;\n    var enc = this.encoding;\n    res += buf.slice(0, cr).toString(enc);\n  }\n\n  return res;\n};\n\nfunction passThroughWrite(buffer) {\n  return buffer.toString(this.encoding);\n}\n\nfunction utf16DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 2;\n  this.charLength = this.charReceived ? 2 : 0;\n}\n\nfunction base64DetectIncompleteChar(buffer) {\n  this.charReceived = buffer.length % 3;\n  this.charLength = this.charReceived ? 3 : 0;\n}\n"]} diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js index 6928bf8..5154db0 100644 --- a/examples/file-uploader/js/upload.js +++ b/examples/file-uploader/js/upload.js @@ -77,7 +77,7 @@ const percentProgress = (p) => { // action -// NOTE: no async tasks initiated, so all updates simply return changed state +// NOTE: no side-effects initiated, so all updates simply return changed state const Action = Type({ Progress: [Function, hasProgressData], @@ -103,29 +103,24 @@ const update = Action.caseOn({ const view = curry( ({progress},model) => { - const style = { 'display': 'inline-block' }; - - const substyle = { 'display': 'inline-block', - 'vertical-align': 'top', - 'margin-right': '1rem' - }; - progress = merge({width: 200, height: 20}, progress || {}); return ( - h('div', { attrs: { 'class': 'upload ' + model.status }, style }, [ - h('div.title', {style: substyle}, [ renderTitle(model) ]), - h('div.size', {style: substyle}, [ ''+size(model) ]), - h('div.progress', {style: substyle}, [ renderProgress(model,progress) ]), - h('div.status', {style: substyle}, [ renderStatus(model) ]), - h('div.abort', {style: dissoc('margin-right',substyle)}, - [ renderAbort(model) ]) + h('div', { attrs: { 'class': 'upload ' + model.status }, + style: style.upload + }, [ + h('div.title', {style: style.div}, [ renderTitle(model) ]), + h('div.size', {style: style.div}, [ ''+size(model) ]), + h('div.progress', {style: style.div}, [ renderProgress(model,progress) ]), + h('div.status', {style: style.div}, [ renderStatus(model) ]), + h('div.abort', {style: dissoc('margin-right', style.div)}, + [ renderAbort(model) ]) ]) ); }); -function renderTitle(model){ +const renderTitle = (model) => { return ( model.url ? h('a', { attrs: {'href': model.url, @@ -138,7 +133,7 @@ function renderTitle(model){ } -function renderProgress(model,specs){ +const renderProgress = (model,specs) => { const barwidth = percentProgress(model.progress) * specs.width; const linespecs = { x1: specs.width, x2: specs.width, y1: 0, y2: specs.height }; @@ -163,13 +158,12 @@ function renderProgress(model,specs){ } -function renderStatus(model){ - const label = statusLabel(model); - return h('span', {}, label); +const renderStatus = (model) => { + return h('span', {}, statusLabel(model)); } -function renderAbort(model){ +const renderAbort = (model) => { const label = actionLabel('abort'); return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}), on: { click: model.abort } }, @@ -177,6 +171,20 @@ function renderAbort(model){ ); } + +// view styles + +const style = { + upload: { 'display': 'inline-block' }, + div: { 'display': 'inline-block', + 'vertical-align': 'top', + 'margin-right': '1rem' + } +} + + +// view utils + function visible(pred,model){ return { display: pred(model) ? null : 'none' } } diff --git a/examples/file-uploader/package.json b/examples/file-uploader/package.json index c27a0d7..2c44587 100644 --- a/examples/file-uploader/package.json +++ b/examples/file-uploader/package.json @@ -4,13 +4,14 @@ "description": "File uploader example", "main": "index.js", "scripts": { - "pretest": "browserify js/test.js --debug -t /usr/lib/node_modules/babelify --outfile js/test_build.js", - "test": "node js/test_build.js | ./node_modules/tap-spec/bin/cmd.js", - "build": "browserify js/main.js --debug -t /usr/lib/node_modules/babelify --outfile js/build.js" + "pretest": "browserify js/test.js --debug -t babelify --outfile js/test_build.js", + "test": "node js/test_build.js | tap-spec", + "build": "browserify js/main.js --debug -t babelify --outfile js/build.js" }, "author": "Eric Gjertsen", "license": "MIT", "devDependencies": { + "babelify": "^6.1.1", "tape": "^4.2.0", "tap-spec": "^4.1.0", "multiparty": "^4.1.0" From 07900614884c8a24b8d4fb1a2930df57f1dd5c78 Mon Sep 17 00:00:00 2001 From: Eric Gjertsen Date: Thu, 3 Sep 2015 12:57:10 -0400 Subject: [PATCH 9/9] file-uploader example: more minor code style tweaks --- examples/file-uploader/index.html | 8 ++ examples/file-uploader/js/build.js | 45 ++++++------ examples/file-uploader/js/list.js | 28 +++---- examples/file-uploader/js/upload.js | 110 +++++++++++++--------------- 4 files changed, 91 insertions(+), 100 deletions(-) diff --git a/examples/file-uploader/index.html b/examples/file-uploader/index.html index 98b5998..b4dd27f 100644 --- a/examples/file-uploader/index.html +++ b/examples/file-uploader/index.html @@ -42,6 +42,14 @@ fill: steelblue; } + .upload.error > .progress rect.bar { + fill: red; + } + + .upload.abort > .progress rect.bar { + fill: lightgrey; + } + .upload > .progress line.end { stroke: lightgrey; stroke-width: 1; diff --git a/examples/file-uploader/js/build.js b/examples/file-uploader/js/build.js index d9705f0..81916e9 100644 --- a/examples/file-uploader/js/build.js +++ b/examples/file-uploader/js/build.js @@ -148,7 +148,6 @@ var nextIndex = function nextIndex(model) { // view var view = function view(model) { - return h('ul', { style: style.ul }, model.map(listItemView)); }; @@ -252,27 +251,9 @@ var initFile = function initFile(_ref) { var lastModifiedDate = _ref.lastModifiedDate; var size = _ref.size; var type = _ref.type; - return { name: name, lastModifiedDate: lastModifiedDate, size: size, type: type }; }; -var statusLabel = function statusLabel(model) { - return ({ - 'initial': null, - 'uploading': 'uploading', - 'processing': 'processing', - 'uploaded': 'done', - 'error': 'error', - 'abort': 'stopped' - })[model.status] || null; -}; - -var actionLabel = function actionLabel(action) { - return ({ - 'abort': '×' - })[action] || null; -}; - var size = function size(model) { return reduce(function (tot, file) { return tot + (file.size || 0); @@ -367,9 +348,25 @@ var renderStatus = function renderStatus(model) { }; var renderAbort = function renderAbort(model) { - var label = actionLabel('abort'); return h('a', { style: merge(visible(abortable, model), { cursor: 'pointer' }), - on: { click: model.abort } }, label); + on: { click: model.abort } }, actionLabel('abort')); +}; + +var statusLabel = function statusLabel(model) { + return ({ + 'initial': null, + 'uploading': 'uploading', + 'processing': 'processing', + 'uploaded': 'done', + 'error': 'error', + 'abort': 'stopped' + })[model.status] || null; +}; + +var actionLabel = function actionLabel(action) { + return ({ + 'abort': '×' + })[action] || null; }; // view styles @@ -384,9 +381,9 @@ var style = { // view utils -function visible(pred, model) { +var visible = function visible(pred, model) { return { display: pred(model) ? null : 'none' }; -} +}; module.exports = { init: init, Action: Action, update: update, view: view }; @@ -10530,4 +10527,4 @@ function Type(desc) { module.exports = Type; },{"ramda/src/curryN":79}]},{},[3]) -//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAS,CAAA;AAC5B,IAAM,cAAc,GAAG,EAAE,CAAA;;;;AAKzB,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK;WACrB,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE;GACxD;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAS,EAAE,KAAK,EAAK;MAApB,OAAO,GAAR,IAAS,CAAR,OAAO;;AAE3B,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;;AAEvD,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,EACjB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,OAAO,EAAE,EAAE;SACvB,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD;CACF,CAAC;;AAGF,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;AChF/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,CAAC,CAAC,MAAM,KAAK,SAAS;CAAA,CAAA;;;;AAIhD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;;AAEtB,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAE,CACtD;CAEH,CAAC;;AAEF,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC,EAAK;AAChC,SACE,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,CACzB,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CACF,CAAC,CACF;CACH,CAAA;;AAGD,IAAM,KAAK,GAAG;AACZ,IAAE,EAAE,EAAC,YAAY,EAAE,MAAM,EAAC;AAC1B,IAAE,EAAE,EAAG;CACR,CAAA;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;ACrF/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1D,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO;AACL,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B,CAAA;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC,EAAK;MAArC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;;AAChD,SAAO,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC,CAAA;CACzC,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SAAO,CAAA;AACL,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CAC1B,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM,EAAK;AAC9B,SAAO,CAAA;AACL,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI,CAAE;CACpB,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK,EAAK;AACtB,SAAO,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACvE,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK,EAAK;AACzB,SAAO,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;CAClC,CAAA;;AAED,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK,EAAK;AAC3B,SAAO,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;CAC/D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,SAAO,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC,CAAC;CAC3D,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE;AAC5C,SAAK,EAAE,KAAK,CAAC,MAAM;GACpB,EAAG,CACX,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EAC1E,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EAC1E,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EAC1E,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EAC1E,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC,EACrB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC3E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,SACE,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,CACnC;CACH,CAAA;;AAGD,IAAM,cAAc,GAAG,SAAjB,cAAc,CAAI,KAAK,EAAC,KAAK,EAAK;AACtC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH,CAAA;;AAED,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,KAAK,EAAK;AAC9B,SAAO,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;CAC1C,CAAA;;AAGD,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK,EAAK;AAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;AACnC,SAAO,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAC9B,KAAK,CACV,CAAC;CACX,CAAA;;;;AAKD,IAAM,KAAK,GAAG;AACZ,QAAM,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;AACrC,KAAG,EAAK,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB;CACV,CAAA;;;;AAKD,SAAS,OAAO,CAAC,IAAI,EAAC,KAAK,EAAC;AAC1B,SAAO,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE,CAAA;CAChD;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;AC9L9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// app constants\n\nconst UPLOAD_URL = '/upload'\nconst UPLOAD_HEADERS = {}\n\n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => (\n    listUpdate( uploadList.Action.Create(up,files), model )\n  ),\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({action$}, model) => {\n\n  const up = uploader.upload(UPLOAD_HEADERS, UPLOAD_URL);\n  \n  return (\n    h('div.uploading', {}, [\n      form(action$, up),\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst form = (action$, up) => (\n  h('form', {on: {submit: preventDefault} }, [\n     h('input', \n       { props: {type: 'file', multiple: true},\n         on:   {\n           change: compose(action$, Action.Create(up), getTarget('files')) \n         }\n       }\n     )\n   ]\n  )\n);\n\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst noFx = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => x.length !== undefined\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return noFx(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => {\n\n  return (\n    h('ul', {style: style.ul}, model.map( listItemView ) )\n  );\n\n};\n\nconst listItemView = (item, i) => {\n  return (\n    h('li', {style: style.li}, [\n      upload.view(\n        { progress: { height: 20, width: 200 } },\n        item\n      )   \n    ])\n  );\n}\n\n\nconst style = {\n  ul: {'list-style': 'none'},\n  li: { }\n}\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => {\n  return {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n}\n\nconst initFile = ({name,lastModifiedDate,size,type}) => {\n  return {name,lastModifiedDate,size,type}\n}\n\nconst statusLabel = (model) => {\n  return {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null ;\n}\n\nconst actionLabel = (action) => {\n  return {\n    'abort': '×'\n  }[action] || null ;\n}\n\nconst size = (model) => {\n  return reduce( (tot,file) => tot + (file.size || 0), 0, model.files );\n}\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => {\n  return model.status == 'aborted';\n}\n\nconst abortable = (model) => {\n  return !!model.abort && contains(model.status, ['uploading']);\n}\n\nconst hasProgressData = (x) => {\n  return !(x.loaded === undefined || x.total === undefined);\n}\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no side-effects initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, \n               style: style.upload \n             },  [\n      h('div.title',    {style: style.div},  [ renderTitle(model)             ]),\n      h('div.size',     {style: style.div},  [ ''+size(model)                 ]),\n      h('div.progress', {style: style.div},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: style.div},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right', style.div)},   \n                                             [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nconst renderTitle = (model) => {\n  return (\n    model.url\n      ?  h('a', { attrs: {'href': model.url,\n                          'target': '_blank'\n                         } \n                }, [ model.title ])\n\n      :  h('span', {}, [ model.title ]) \n  );\n}\n\n\nconst renderProgress = (model,specs) => {\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nconst renderStatus = (model) => {\n  return h('span', {}, statusLabel(model));\n}\n\n\nconst renderAbort = (model) => {\n  const label = actionLabel('abort');\n  return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n                  on: { click: model.abort } }, \n                label\n          );\n}\n\n\n// view styles \n\nconst style = { \n  upload: { 'display': 'inline-block' }, \n  div:    { 'display': 'inline-block',\n            'vertical-align': 'top',\n            'margin-right': '1rem'\n          }\n}\n\n\n// view utils\n\nfunction visible(pred,model){\n  return { display: pred(model) ? null : 'none' }\n}\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} +//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["../../../../../../usr/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/app.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/list.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/main.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/svg.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/upload.js","/media/sf_dev-home/forks/nfff/examples/file-uploader/js/uploader.js","node_modules/ramda-fantasy/src/Future.js","node_modules/ramda/dist/ramda.js","node_modules/ramda/src/T.js","node_modules/ramda/src/__.js","node_modules/ramda/src/adjust.js","node_modules/ramda/src/always.js","node_modules/ramda/src/append.js","node_modules/ramda/src/assoc.js","node_modules/ramda/src/bind.js","node_modules/ramda/src/compose.js","node_modules/ramda/src/contains.js","node_modules/ramda/src/curry.js","node_modules/ramda/src/curryN.js","node_modules/ramda/src/dissoc.js","node_modules/ramda/src/equals.js","node_modules/ramda/src/evolve.js","node_modules/ramda/src/filter.js","node_modules/ramda/src/identical.js","node_modules/ramda/src/internal/_arity.js","node_modules/ramda/src/internal/_checkForMethod.js","node_modules/ramda/src/internal/_cloneRegExp.js","node_modules/ramda/src/internal/_complement.js","node_modules/ramda/src/internal/_concat.js","node_modules/ramda/src/internal/_contains.js","node_modules/ramda/src/internal/_curry1.js","node_modules/ramda/src/internal/_curry2.js","node_modules/ramda/src/internal/_curry3.js","node_modules/ramda/src/internal/_curryN.js","node_modules/ramda/src/internal/_dispatchable.js","node_modules/ramda/src/internal/_equals.js","node_modules/ramda/src/internal/_filter.js","node_modules/ramda/src/internal/_has.js","node_modules/ramda/src/internal/_hasMethod.js","node_modules/ramda/src/internal/_indexOf.js","node_modules/ramda/src/internal/_isArray.js","node_modules/ramda/src/internal/_isTransformer.js","node_modules/ramda/src/internal/_map.js","node_modules/ramda/src/internal/_pipe.js","node_modules/ramda/src/internal/_quote.js","node_modules/ramda/src/internal/_reduce.js","node_modules/ramda/src/internal/_slice.js","node_modules/ramda/src/internal/_toISOString.js","node_modules/ramda/src/internal/_toString.js","node_modules/ramda/src/internal/_xfBase.js","node_modules/ramda/src/internal/_xfilter.js","node_modules/ramda/src/internal/_xmap.js","node_modules/ramda/src/internal/_xwrap.js","node_modules/ramda/src/invoker.js","node_modules/ramda/src/is.js","node_modules/ramda/src/isArrayLike.js","node_modules/ramda/src/keys.js","node_modules/ramda/src/map.js","node_modules/ramda/src/merge.js","node_modules/ramda/src/pipe.js","node_modules/ramda/src/reduce.js","node_modules/ramda/src/reject.js","node_modules/ramda/src/reverse.js","node_modules/ramda/src/slice.js","node_modules/ramda/src/tail.js","node_modules/ramda/src/test.js","node_modules/ramda/src/toString.js","node_modules/ramda/src/type.js","node_modules/snabbdom/h.js","node_modules/snabbdom/is.js","node_modules/snabbdom/modules/attributes.js","node_modules/snabbdom/modules/class.js","node_modules/snabbdom/modules/eventlisteners.js","node_modules/snabbdom/modules/props.js","node_modules/snabbdom/modules/style.js","node_modules/snabbdom/snabbdom.js","node_modules/snabbdom/vnode.js","node_modules/union-type/node_modules/ramda/src/arity.js","node_modules/union-type/node_modules/ramda/src/curryN.js","node_modules/union-type/node_modules/ramda/src/internal/_curry1.js","node_modules/union-type/node_modules/ramda/src/internal/_curryN.js","node_modules/union-type/union-type.js"],"names":[],"mappings":"AAAA;;;;;ACCA,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,OAAO,GAAI,OAAO,CAAC,mBAAmB,CAAC;IACvC,GAAG,GAAI,OAAO,CAAC,eAAe,CAAC;IAC/B,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAC3C;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AACrC,IAAM,QAAQ,GAAK,OAAO,CAAC,YAAY,CAAC,CAAC;;;;AAKzC,IAAM,UAAU,GAAG,SAAS,CAAA;AAC5B,IAAM,cAAc,GAAG,EAAE,CAAA;;;;AAKzB,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,UAAU,EAAC,KAAK,EAAK;2BAChB,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC;;;;MAA5D,KAAK;MAAE,KAAK;;AACnB,SAAO,CAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAC9B,KAAK,CAAC,GAAG,CAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAE,CAC/B,CAAC;CACV,CAAA;;AAED,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;AACd,OAAK,EAAG,CAAC,UAAU,CAAC,MAAM,CAAC;CAC5B,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK;WACrB,UAAU,CAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAC,KAAK,CAAC,EAAE,KAAK,CAAE;GACxD;;AAED,OAAK,EAAE,UAAU;CAClB,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI,GAAS;AAAE,SAAO,EAAE,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;CAAE,CAAA;;;;AAI7D,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,IAAS,EAAE,KAAK,EAAK;MAApB,OAAO,GAAR,IAAS,CAAR,OAAO;;AAE3B,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;;AAEvD,SACE,CAAC,CAAC,eAAe,EAAE,EAAE,EAAE,CACrB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,EACjB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC,CACF;CACH,CAAC,CAAC;;AAEH,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,OAAO,EAAE,EAAE;SACvB,CAAC,CAAC,MAAM,EAAE,EAAC,EAAE,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,EAAE,EAAE,CACxC,CAAC,CAAC,OAAO,EACP,EAAE,KAAK,EAAE,EAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAC;AACrC,MAAE,EAAI;AACJ,YAAM,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;KAChE;GACF,CACF,CACF,CACD;CACF,CAAC;;AAGF,IAAM,SAAS,GAAG,KAAK,CAAE,UAAC,GAAG,EAAC,CAAC;SAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;CAAA,CAAE,CAAC;AACpD,IAAM,cAAc,GAAG,OAAO,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;;AAGpD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;AChF/C,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAC1B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC,CACxC;AACD,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,IAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACnC,IAAM,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEvC,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,CAAC;SAAK,CAAC,CAAC,EAAE,EAAE,CAAC;CAAA,CAAC;;;;AAI5B,IAAM,UAAU,GAAG,SAAb,UAAU,CAAI,CAAC;SAAK,CAAC,CAAC,MAAM,KAAK,SAAS;CAAA,CAAA;;;;AAIhD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,QAAM,EAAO,CAAC,QAAQ,EAAE,UAAU,CAAC;AACnC,QAAM,EAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC;CACvC,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;;AAE3B,QAAM,EAAE,gBAAC,EAAE,EAAC,KAAK,EAAC,KAAK,EAAK;AAC1B,QAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7B,QAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AACvB,QAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtC,QAAM,QAAQ,GAAG,MAAM,CAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,WAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;GAC3C;;AAED,QAAM,EAAE,gBAAC,CAAC,EAAC,MAAM,EAAC,KAAK,EAAK;AAC1B,QAAM,MAAM,GAAG,SAAT,MAAM,CAAI,IAAI;aAAK,YAAM;AAC7B,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OAC/D;KAAA,CAAC;AACF,WAAO,IAAI,CACT,QAAQ,CAAC,MAAM,QAAK,CAAC;AACnB,QAAE,EAAQ,MAAM,CAAC,UAAU,CAAC;AAC5B,cAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,WAAK,EAAK,MAAM,CAAC,OAAO,CAAC;AACzB,cAAQ,EAAE,kBAAC,KAAK,EAAC,CAAC,EAAK;AACrB,eAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;OACzE;KACF,EAAE,MAAM,CAAC,CACX,CAAC;GACH;;CAEF,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,SAAP,IAAI;SAAS,EAAE;CAAA,CAAA;AACrB,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM;CAAA,CAAC;;;;AAI1C,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK;SAAK,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,KAAK,CAAC,GAAG,CAAE,YAAY,CAAE,CAAC;CAAA,CAAA;;AAE7E,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,IAAI,EAAE,CAAC;SAC3B,CAAC,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAC,EAAE,CACzB,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EACxC,IAAI,CACL,CACF,CAAC;CACH,CAAA;;AAGD,IAAM,KAAK,GAAG;AACZ,IAAE,EAAE,EAAC,YAAY,EAAE,MAAM,EAAC;AAC1B,IAAE,EAAE,EAAG;CACR,CAAA;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAE,CAAA;;;;;;;;;AC7E/C,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACrC,IAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CACrC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,wBAAwB,CAAC,EACjC,OAAO,CAAC,6BAA6B,CAAC,EACtC,OAAO,CAAC,iCAAiC,CAAC,CAC3C,CAAC,CAAC;;AAEH,IAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE7B,IAAI,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE;IAAE,YAAY,YAAA;IAAE,KAAK,YAAA,CAAA;;AAE3C,IAAM,MAAM,GAAG,SAAT,MAAM,GAAS;AACnB,OAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,EAAC,OAAO,EAAE,MAAM,EAAC,EAAE,KAAK,CAAC,CAAC,CAAC;CAC1D,CAAC;;AAEF,IAAM,MAAM,GAAG,SAAT,MAAM,CAAI,MAAM,EAAK;oBACD,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;;;;AAAhD,OAAK;AAAE,cAAY;;AACpB,KAAG,CAAC,UAAC,CAAC;WAAK,CAAC,CAAC,IAAI,CAAC,UAAC,GAAG,EAAK;AAAC,YAAM,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC;GAAA,EAAE,YAAY,CAAC,CAAC;AAC/D,SAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnB,QAAM,EAAE,CAAC;CACV,CAAC;;AAEF,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,YAAM;AAChD,OAAK,GAAG,QAAQ,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;AAC7C,QAAM,EAAE,CAAC;CACV,CAAC,CAAC;;;;;AC7BH,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEhC,MAAM,CAAC,OAAO,GAAG,SAAS,GAAG,GAAS;AACpC,MAAM,KAAK,GAAG,CAAC,4BAAS,CAAC;AACzB,OAAK,CAAC,IAAI,CAAC,EAAE,GAAG,4BAA4B,CAAC;AAC7C,SAAO,KAAK,CAAC;CACd,CAAA;;;;;ACND,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;;AAEnC,IAAM,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;IAC9B,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IACpC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,QAAQ,GAAI,OAAO,CAAC,oBAAoB,CAAC;IACzC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,KAAK,GAAI,OAAO,CAAC,iBAAiB,CAAC;IACnC,MAAM,GAAI,OAAO,CAAC,kBAAkB,CAAC;IACrC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;;AAED,IAAM,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;IACzB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;;AAE3B,IAAM,IAAI,GAAG,SAAP,IAAI,GAAa,EAAE,CAAC;;;;AAI1B,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK;SACjB;AACE,UAAM,EAAE,SAAS;AACjB,YAAQ,EAAE,EAAE;AACZ,SAAK,EAAE,IAAI;AACX,SAAK,EAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GACd,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GACb,GAAG,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,AAAE;AAC5C,SAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC;GAC5B;CACF,CAAA;;AAED,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,IAAiC;MAAhC,IAAI,GAAL,IAAiC,CAAhC,IAAI;MAAC,gBAAgB,GAAtB,IAAiC,CAA3B,gBAAgB;MAAC,IAAI,GAA3B,IAAiC,CAAV,IAAI;MAAC,IAAI,GAAhC,IAAiC,CAAL,IAAI;SAChD,EAAC,IAAI,EAAJ,IAAI,EAAC,gBAAgB,EAAhB,gBAAgB,EAAC,IAAI,EAAJ,IAAI,EAAC,IAAI,EAAJ,IAAI,EAAC;CAClC,CAAA;;AAED,IAAM,IAAI,GAAG,SAAP,IAAI,CAAI,KAAK;SACjB,MAAM,CAAE,UAAC,GAAG,EAAC,IAAI;WAAK,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,CAAA,AAAC;GAAA,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAE;CAC/D,CAAA;;AAED,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,CAAC,EAAE,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,CAAC;CAAA,CAAE,CAAC;AACxD,IAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;;AAEtC,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,KAAK;SAAK,KAAK,CAAC,MAAM,IAAI,SAAS;CAAA,CAAA;;AAEpD,IAAM,SAAS,GAAG,SAAZ,SAAS,CAAI,KAAK;SACtB,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC;CACvD,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC;SACxB,EAAE,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAA,AAAC;CACnD,CAAA;;AAED,IAAM,eAAe,GAAG,SAAlB,eAAe,CAAI,CAAC,EAAK;AAC7B,MAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC;AACrC,SAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;CAC3B,CAAA;;;;;;AAOD,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC;AACrC,UAAQ,EAAE,EAAE;AACZ,OAAK,EAAE,EAAE;AACT,OAAK,EAAE,EAAE;CACV,CAAC,CAAC;;AAEH,IAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC3B,UAAQ,EAAE,kBAAC,KAAK,EAAC,KAAc,EAAC,KAAK,EAAK;QAAxB,MAAM,GAAP,KAAc,CAAb,MAAM;QAAC,KAAK,GAAb,KAAc,CAAN,KAAK;;AAC5B,WAAO,MAAM,CAAC,EAAE,MAAM,EAAI,MAAM,CAAC,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,YAAY,CAAC;AAC7D,cAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAN,MAAM,EAAE,KAAK,EAAL,KAAK,EAAC,CAAC;AACjC,WAAK,EAAG,MAAM,CAAC,KAAK,CAAC;KACvB,CAAC,CAAC,KAAK,CAAC,CAAC;GACxB;AACD,UAAQ,EAAE,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAC,CAAC;AAC9C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;AAC3C,OAAK,EAAK,MAAM,CAAC,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAC,CAAC;CAC5C,CAAC,CAAC;;;;AAKH,IAAM,IAAI,GAAG,KAAK,CAAE,UAAC,KAAU,EAAC,KAAK,EAAK;MAApB,QAAQ,GAAT,KAAU,CAAT,QAAQ;;AAE5B,UAAQ,GAAG,KAAK,CAAC,EAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAC,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;;AAE3D,SACE,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE;AAC5C,SAAK,EAAE,KAAK,CAAC,MAAM;GACpB,EAAG,CACX,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,EAC1E,CAAC,CAAC,UAAU,EAAM,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,EAAE,GAAC,IAAI,CAAC,KAAK,CAAC,CAAkB,CAAC,EAC1E,CAAC,CAAC,cAAc,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,cAAc,CAAC,KAAK,EAAC,QAAQ,CAAC,CAAE,CAAC,EAC1E,CAAC,CAAC,YAAY,EAAI,EAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAC,EAAG,CAAE,YAAY,CAAC,KAAK,CAAC,CAAa,CAAC,EAC1E,CAAC,CAAC,WAAW,EAAK,EAAC,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,GAAG,CAAC,EAAC,EACrB,CAAE,WAAW,CAAC,KAAK,CAAC,CAAc,CAAC,CAC3E,CAAC,CACF;CAEH,CAAC,CAAC;;AAEH,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK;SACxB,KAAK,CAAC,GAAG,GACJ,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAC,MAAM,EAAE,KAAK,CAAC,GAAG;AACjB,cAAQ,EAAE,QAAQ;KAClB;GACT,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC,GAE1B,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,CAAE,KAAK,CAAC,KAAK,CAAE,CAAC;CACpC,CAAA;;AAGD,IAAM,cAAc,GAAG,SAAjB,cAAc,CAAI,KAAK,EAAC,KAAK,EAAK;AACtC,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;AAC/D,MAAM,SAAS,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,KAAK;AAChC,MAAE,EAAE,CAAC,EAAY,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;;AAExD,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM;AACpB,WAAK,EAAE,QAAQ;AACf,eAAO,KAAK;KACb;GACT,CAAC,AACb,CAAC;;AAEF,MAAM,IAAI,GACR,CAAC,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,EAAC,SAAO,KAAK,EAAC,CAAC,EAAE,CAAE,AACxD,CAAC;;AAEF,SACE,CAAC,CAAC,KAAK,EAAE,EAAC,KAAK,EAAE,KAAK,EAAC,EAAE,CACvB,CAAC,CAAC,GAAG,EAAE,EAAE,EAAE,AAAC,QAAQ,GAAG,CAAC,GAAI,CAAC,IAAI,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAC7C,CAAC,CACH;CAEH,CAAA;;AAED,IAAM,YAAY,GAAG,SAAf,YAAY,CAAI,KAAK;SAAK,CAAC,CAAC,MAAM,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;CAAA,CAAA;;AAGjE,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK;SACxB,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAC,MAAM,EAAE,SAAS,EAAC,CAAC;AAC5D,MAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,EAAE,EACnC,WAAW,CAAC,OAAO,CAAC,CACrB;CACF,CAAA;;AAGD,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,KAAK;SACxB,CAAA;AACE,aAAS,EAAE,IAAI;AACf,eAAW,EAAE,WAAW;AACxB,gBAAY,EAAE,YAAY;AAC1B,cAAU,EAAE,MAAM;AAClB,WAAO,EAAE,OAAO;AAChB,WAAO,EAAE,SAAS;IACnB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI;CACxB,CAAA;;AAED,IAAM,WAAW,GAAG,SAAd,WAAW,CAAI,MAAM;SACzB,CAAA;AACE,WAAO,EAAE,GAAG;IACb,CAAC,MAAM,CAAC,IAAI,IAAI;CAClB,CAAA;;;;AAKD,IAAM,KAAK,GAAG;AACZ,QAAM,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE;AACrC,KAAG,EAAK,EAAE,SAAS,EAAE,cAAc;AACzB,oBAAgB,EAAE,KAAK;AACvB,kBAAc,EAAE,MAAM;GACvB;CACV,CAAA;;;;AAKD,IAAM,OAAO,GAAG,SAAV,OAAO,CAAI,IAAI,EAAC,KAAK;SACzB,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,MAAM,EAAE;CACzC,CAAA;;AAGD,MAAM,CAAC,OAAO,GAAG,EAAC,IAAI,EAAJ,IAAI,EAAE,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAE,IAAI,EAAJ,IAAI,EAAC,CAAC;;;;;;;ACxL9C,IAAM,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC;IACtC,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAC5B,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAClC,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CACzC;AACD,IAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AACnC,IAAM,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;;AAEnD,IAAM,QAAQ,GAAG,SAAX,QAAQ,CAAI,CAAC;SAAK,CAAC;CAAA,CAAE;;AAE3B,IAAM,MAAM,GAAG,IAAI,CAAC;AAClB,IAAE,EAAE,CAAC,MAAM,CAAC;AACZ,UAAQ,EAAE,CAAC,MAAM,CAAC;AAClB,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,OAAK,EAAE,CAAC,MAAM,CAAC;AACf,SAAO,EAAG,CAAC,MAAM,CAAC;AAClB,UAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B,CAAC,CAAC;;AAGH,IAAM,MAAM,GAAG,KAAK,CAAE,UAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAK;AAC7C,SAAO,GAAG,OAAO,IAAI,EAAE,CAAC;;AAExB,SAAO,IAAI,MAAM,CAAE,UAAC,GAAG,EAAC,GAAG,EAAK;AAC9B,QAAM,GAAG,GAAG,IAAI,cAAc,EAAE,CAAC;AACjC,QAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3B,QAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACjC,OAAG,CAAC,gBAAgB,CAAC,MAAM,EAAG,OAAO,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;AACzE,OAAG,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EACV,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;;AAEzE,OAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,SAAK,CAAC,IAAI,OAAO,EAAC;AAChB,SAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;KACrC;AACD,OAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;GAC3B,CAAC,CAAC;CACJ,CAAC,CAAC;;AAEH,MAAM,CAAC,OAAO,GAAG,EAAC,MAAM,EAAN,MAAM,EAAE,MAAM,EAAN,MAAM,EAAC,CAAA;;AAGjC,SAAS,YAAY,CAAC,GAAG,EAAC;AACxB,SAAO,CAAC,GAAG,CAAC,MAAM,GAAI,GAAG,GAAuB,MAAM,CAAC,EAAE,GACjD,GAAG,CAAC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,GACvD,GAAG,CAAC,MAAM,IAAI,GAAG,GAAuB,MAAM,CAAC,KAAK,GACZ,MAAM,CAAC,OAAO,CAAA,CACrD,GAAG,CAAC,CAAC;CACf;;AAED,SAAS,QAAQ,CAAC,KAAK,EAAC;AACtB,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAC5B,OAAK,IAAI,CAAC,GAAC,CAAC,EAAE,CAAC,GAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;AAAE,QAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;GAAA,AACxE,OAAO,IAAI,CAAC;CACb;;;AC3DD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxzOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACb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nDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nconst Type = require('union-type');\nconst T = require('ramda/src/T')\n    , assoc = require('ramda/src/assoc')\n    , curry  = require('ramda/src/curry')\n    , compose  = require('ramda/src/compose')\n    , map  = require('ramda/src/map')\n    , invoker = require('ramda/src/invoker') \n;\nconst h = require('snabbdom/h');\n\nconst uploadList = require('./list');\nconst uploader   = require('./uploader');\n  \n\n// app constants\n\nconst UPLOAD_URL = '/upload'\nconst UPLOAD_HEADERS = {}\n\n\n// action\n\nconst listUpdate = (listAction,model) => {\n  const [state, tasks] = uploadList.update(listAction, model.uploads);\n  return [ assoc('uploads', state, model), \n           tasks.map( map(Action.Route) ) \n         ];\n}\n\nconst Action = Type({\n  Create: [T, T],\n  Route:  [uploadList.Action]\n});\n\nconst update = Action.caseOn({\n  Create: (up,files,model) => (\n    listUpdate( uploadList.Action.Create(up,files), model )\n  ),\n\n  Route: listUpdate\n});\n\n\n// model\n\nconst init = () => { return { uploads: uploadList.init() }; }\n\n// view\n\nconst view = curry( ({action$}, model) => {\n\n  const up = uploader.upload(UPLOAD_HEADERS, UPLOAD_URL);\n  \n  return (\n    h('div.uploading', {}, [\n      form(action$, up),\n      uploadList.view(model.uploads)\n    ])\n  );\n});\n\nconst form = (action$, up) => (\n  h('form', {on: {submit: preventDefault} }, [\n     h('input', \n       { props: {type: 'file', multiple: true},\n         on:   {\n           change: compose(action$, Action.Create(up), getTarget('files')) \n         }\n       }\n     )\n   ]\n  )\n);\n\n\nconst getTarget = curry( (key,e) => e.target[key] );\nconst preventDefault = invoker(0, 'preventDefault');\n\n\nmodule.exports = { init, update, Action, view }\n\n","const Type = require('union-type');\nconst T = require('ramda/src/T')\n    , adjust = require('ramda/src/adjust')\n    , append = require('ramda/src/append')\n    , curry  = require('ramda/src/curry')\n;\nconst h = require('snabbdom/h');\n\nconst upload = require('./upload');\nconst uploader = require('./uploader');\n\nconst noFx = (s) => [s, []];\n\n// note: prefer to check if iterable, \n// but FileList.prototype doesn't seem to have Symbol.iterator cross-browser?\nconst isFileList = (x) => x.length !== undefined\n\n// action\n\nconst Action = Type({\n  Create:      [Function, isFileList],\n  Result:      [Number, uploader.Result]\n});\n\nconst update = Action.caseOn({\n\n  Create: (up,files,model) => {\n    const idx = nextIndex(model);\n    const task = up(files);\n    const taskAction = Action.Result(idx);\n    const newState = append( upload.init(files), model);\n    return [newState, [task.map(taskAction)]];\n  },\n  \n  Result: (i,result,model) => {\n    const finish = (type) => () => {\n      return adjust(upload.update(upload.Action[type]()), i, model);\n    };\n    return noFx(\n      uploader.Result.case({\n        OK:       finish('Uploaded'),\n        NotFound: finish('Error'),\n        Error:    finish('Error'),\n        Abort:    finish('Abort'), \n        Progress: (abort,p) => {\n          return adjust(upload.update(upload.Action.Progress(abort,p)), i, model);\n        }\n      }, result)\n    );\n  }\n\n});\n\n\n// model\n\nconst init = () => []\nconst nextIndex = (model) => model.length;\n\n// view\n\nconst view = (model) => h('ul', {style: style.ul}, model.map( listItemView ))\n\nconst listItemView = (item, i) => (\n  h('li', {style: style.li}, [\n    upload.view(\n      { progress: { height: 20, width: 200 } },\n      item\n    )   \n  ])\n)\n\n\nconst style = {\n  ul: {'list-style': 'none'},\n  li: { }\n}\n\n\nmodule.exports = { init, update, Action, view }\n\n","/* globals: document, window */\n\nconst map = require('ramda/src/map');\nconst patch = require('snabbdom').init([\n  require('snabbdom/modules/class'),\n  require('snabbdom/modules/style'),\n  require('snabbdom/modules/props'),\n  require('snabbdom/modules/attributes'),\n  require('snabbdom/modules/eventlisteners')\n]);\n\nconst app = require('./app');\n\nlet state = app.init(), asyncActions, vnode\n\nconst render = () => {\n  vnode = patch(vnode, app.view({action$: update}, state));\n};\n\nconst update = (action) => {\n  [state, asyncActions] = app.update(action, state);\n  map((a) => a.fork((err) => {throw err}, update), asyncActions);\n  console.log(state);\n  render();\n};\n\nwindow.addEventListener('DOMContentLoaded', () => {\n  vnode = document.getElementById('container');\n  render();\n});\n\n","const h = require('snabbdom/h');\n\nmodule.exports = function svg(...args){\n  const vnode = h(...args);\n  vnode.data.ns = 'http://www.w3.org/2000/svg';\n  return vnode;\n}\n\n","const Type = require('union-type');\n\nconst map = require('ramda/src/map')\n    , reduce = require('ramda/src/reduce')\n    , curry  = require('ramda/src/curry')\n    , contains  = require('ramda/src/contains')\n    , always  = require('ramda/src/always')\n    , merge  = require('ramda/src/merge')\n    , evolve  = require('ramda/src/evolve')\n    , dissoc = require('ramda/src/dissoc')\n;\n\nconst h = require('snabbdom/h')\n    , s = require('./svg');\n\nconst noop = function(){};\n\n// model\n\nconst init = (files) => (\n  {\n    status: 'initial',\n    progress: {},\n    abort: noop,\n    title: (files.length === 1 \n              ? files[0].name \n              : '(' + files.length + ' files)' ),\n    files: map(initFile, files)\n  }\n)\n\nconst initFile = ({name,lastModifiedDate,size,type}) => (\n  {name,lastModifiedDate,size,type}\n)\n\nconst size = (model) => (\n  reduce( (tot,file) => tot + (file.size || 0), 0, model.files )\n)\n\nconst status = curry( (s, model) => model.status == s );\nconst uploading = status('uploading');\n\nconst aborted = (model) => model.status == 'aborted'\n\nconst abortable = (model) => (\n  !!model.abort && contains(model.status, ['uploading'])\n)\n\nconst hasProgressData = (x) => (\n  !(x.loaded === undefined || x.total === undefined) \n)\n\nconst percentProgress = (p) => {\n  if (!hasProgressData(p)) return null;\n  return p.loaded / p.total;\n}\n\n\n// action\n\n// NOTE: no side-effects initiated, so all updates simply return changed state\n\nconst Action = Type({\n  Progress: [Function, hasProgressData],\n  Uploaded: [],\n  Error: [],\n  Abort: []\n});\n\nconst update = Action.caseOn({\n  Progress: (abort,{loaded,total},model) => {\n    return evolve({ status:   always(loaded < total ? 'uploading' : 'processing'),\n                    progress: always({loaded, total}),\n                    abort:  always(abort)\n                 })(model);\n  },\n  Uploaded: evolve({status: always('uploaded')}),\n  Error:    evolve({status: always('error')}),\n  Abort:    evolve({status: always('abort')})\n});\n\n\n// view\n\nconst view = curry( ({progress},model) => {\n\n  progress = merge({width: 200, height: 20}, progress || {});\n  \n  return (\n    h('div', { attrs: { 'class': 'upload ' + model.status }, \n               style: style.upload \n             },  [\n      h('div.title',    {style: style.div},  [ renderTitle(model)             ]),\n      h('div.size',     {style: style.div},  [ ''+size(model)                 ]),\n      h('div.progress', {style: style.div},  [ renderProgress(model,progress) ]),\n      h('div.status',   {style: style.div},  [ renderStatus(model)            ]),\n      h('div.abort',    {style: dissoc('margin-right', style.div)},   \n                                             [ renderAbort(model)             ])\n    ])\n  );\n\n});\n\nconst renderTitle = (model) => (\n  model.url\n    ?  h('a', { attrs: {'href': model.url,\n                        'target': '_blank'\n                       } \n              }, [ model.title ])\n\n    :  h('span', {}, [ model.title ]) \n)\n\n\nconst renderProgress = (model,specs) => {\n  const barwidth = percentProgress(model.progress) * specs.width;\n  const linespecs = { x1: specs.width, x2: specs.width,\n                      y1: 0,           y2: specs.height };\n\n  const rect = (\n    s('rect', { attrs: { height: specs.height,\n                         width: barwidth,\n                         class: 'bar'\n                       }\n              })\n  );\n\n  const line = (\n    s('line', { attrs: merge(linespecs, {class: 'end'}) } )\n  );\n\n  return (\n    s('svg', {attrs: specs}, [\n      s('g', {}, (barwidth > 0) ? [rect,line] : [])\n     ])       \n  );\n\n}\n\nconst renderStatus = (model) => h('span', {}, statusLabel(model))\n\n\nconst renderAbort = (model) => (\n  h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}),\n           on: { click: model.abort } }, \n    actionLabel('abort')\n  )\n)\n\n\nconst statusLabel = (model) => (\n  {\n    'initial': null,\n    'uploading': 'uploading',\n    'processing': 'processing',\n    'uploaded': 'done',\n    'error': 'error',\n    'abort': 'stopped' \n  }[model.status] || null\n)\n\nconst actionLabel = (action) => (\n  {\n    'abort': '×'\n  }[action] || null\n)\n\n\n// view styles \n\nconst style = { \n  upload: { 'display': 'inline-block' }, \n  div:    { 'display': 'inline-block',\n            'vertical-align': 'top',\n            'margin-right': '1rem'\n          }\n}\n\n\n// view utils\n\nconst visible = (pred,model) => (\n  { display: pred(model) ? null : 'none' }\n)\n\n\nmodule.exports = {init, Action, update, view};\n\n\n","/* globals XMLHttpRequest, FormData */\n\nconst compose = require('ramda/src/compose')\n    , __ = require('ramda/src/__')\n    , curry = require('ramda/src/curry')\n    , always = require('ramda/src/always')\n;\nconst Type = require('union-type');\nconst Future = require('ramda-fantasy/src/Future');\n\nconst identity = (x) => x ;\n\nconst Result = Type({\n  OK: [Object],\n  NotFound: [Object],\n  Error: [Object],\n  Abort: [Object],\n  Unknown:  [Object],\n  Progress: [Function, Object]\n});\n\n\nconst upload = curry( (headers, url, files) => {\n  headers = headers || {};\n\n  return new Future( (rej,res) => {\n    const xhr = new XMLHttpRequest();\n    const getxhr = always(xhr);\n    const abort = xhr.abort.bind(xhr)\n    xhr.addEventListener(\"load\",  compose(res, deriveResult, getxhr), false);\n    xhr.addEventListener(\"abort\", compose(res, Result.Abort, getxhr), false);\n    xhr.addEventListener(\"error\", compose(res, Result.Error, getxhr), false); \n\n    xhr.upload.addEventListener(\"progress\", \n                                compose(res, Result.Progress(abort)), false);\n\n    xhr.open(\"post\", url, true);\n    for (k in headers){\n      xhr.setRequestHeader(k, headers[k]);\n    }\n    xhr.send(formdata(files));\n  });\n});\n\nmodule.exports = {upload, Result}\n\n\nfunction deriveResult(xhr){\n  return (xhr.status <  400                     ? Result.OK :\n          xhr.status >= 400 && xhr.status < 500 ? Result.NotFound :\n          xhr.status >= 500                     ? Result.Error :\n                                                  Result.Unknown\n         )(xhr);\n}\n\nfunction formdata(files){\n  const data = new FormData();\n  for (let i=0; i<files.length; ++i) data.append(files[i].name, files[i]);\n  return data;\n}\n\n","var R = require('ramda');\n\n// `f` is a function that takes two function arguments: `reject` (failure) and `resolve` (success)\nfunction Future(f) {\n  if (!(this instanceof Future)) {\n    return new Future(f);\n  }\n  this._fork = f;\n}\n\nFuture.prototype.fork = function(reject, resolve) {\n  try {\n    this._fork(reject, resolve);\n  } catch(e) {\n    reject(e);\n  }\n};\n\n// functor\nFuture.prototype.map = function(f) {\n  return this.chain(function(a) { return Future.of(f(a)); });\n};\n\n// apply\nFuture.prototype.ap = function(m) {\n  var self = this;\n\n  return new Future(function(rej, res) {\n    var applyFn, val;\n    var doReject = R.once(rej);\n\n    function resolveIfDone() {\n      if (applyFn != null && val != null) {\n        return res(applyFn(val));\n      }\n    }\n\n    self.fork(doReject, function(fn) {\n      applyFn = fn;\n      resolveIfDone();\n    });\n\n    m.fork(doReject, function(v) {\n      val = v;\n      resolveIfDone();\n    });\n\n  });\n\n};\n\n// applicative\nFuture.of = function(x) {\n  // should include a default rejection?\n  return new Future(function(_, resolve) { return resolve(x); });\n};\n\nFuture.prototype.of = Future.of;\n\n// chain\n//  f must be a function which returns a value\n//  f must return a value of the same Chain\n//  chain must return a value of the same Chain\n//:: Future a, b => (b -> Future c) -> Future c\nFuture.prototype.chain = function(f) {  // Sorella's:\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return reject(a); },\n                     function(b) { return f(b).fork(reject, resolve); });\n  }.bind(this));\n};\n\n// chainReject\n// Like chain but operates on the reject instead of the resolve case.\n//:: Future a, b => (a -> Future c) -> Future c\nFuture.prototype.chainReject = function(f) {\n  return new Future(function(reject, resolve) {\n    return this.fork(function(a) { return f(a).fork(reject, resolve); },\n                     function(b) { return resolve(b);\n    });\n  }.bind(this));\n};\n\n// monad\n// A value that implements the Monad specification must also implement the Applicative and Chain specifications.\n// see above.\n\nFuture.prototype.bimap = function(errFn, successFn) {\n  var self = this;\n  return new Future(function(reject, resolve) {\n    self.fork(function(err) {\n      reject(errFn(err));\n    }, function(val) {\n      resolve(successFn(val));\n    });\n  });\n};\n\nFuture.reject = function(val) {\n  return new Future(function(reject) {\n    reject(val);\n  });\n};\n\nFuture.prototype.toString = function() {\n  return 'Future(' + R.toString(this._fork) + ')';\n};\n\nFuture.memoize = function(f) {\n  var status = 'IDLE';\n  var listeners = [];\n  var cachedValue;\n\n  var handleCompletion = R.curry(function(newStatus, cb, val) {\n    status = newStatus;\n    cachedValue = val;\n    cb(val);\n    R.forEach(function(listener) {\n      listener[status](cachedValue);\n    }, listeners);\n  });\n\n  function addListeners(reject, resolve) {\n    listeners.push({ REJECTED: reject, RESOLVED: resolve } );\n  }\n\n  function doResolve(reject, resolve) {\n    status = 'PENDING';\n    return f.fork(\n      handleCompletion('REJECTED', reject),\n      handleCompletion('RESOLVED', resolve)\n    );\n  }\n\n  return new Future(function(reject, resolve) {\n\n    switch(status) {\n      case 'IDLE': doResolve(reject, resolve); break;\n      case 'PENDING': addListeners(reject, resolve); break;\n      case 'REJECTED': reject(cachedValue); break;\n      case 'RESOLVED': resolve(cachedValue); break;\n    }\n\n  });\n};\n\nmodule.exports = Future;\n","//  Ramda v0.17.1\n//  https://github.com/ramda/ramda\n//  (c) 2013-2015 Scott Sauyet, Michael Hurley, and David Chambers\n//  Ramda may be freely distributed under the MIT license.\n\n;(function() {\n\n  'use strict';\n\n  /**\n     * A special placeholder value used to specify \"gaps\" within curried functions,\n     * allowing partial application of any combination of arguments,\n     * regardless of their positions.\n     *\n     * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2, _)(1, 3)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @constant\n     * @memberOf R\n     * @category Function\n     * @example\n     *\n     *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n     *      greet('Alice'); //=> 'Hello, Alice!'\n     */\n    var __ = { '@@functional/placeholder': true };\n\n    // jshint unused:vars\n    var _arity = function _arity(n, fn) {\n        // jshint unused:vars\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.apply(this, arguments);\n            };\n        case 1:\n            return function (a0) {\n                return fn.apply(this, arguments);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.apply(this, arguments);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.apply(this, arguments);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.apply(this, arguments);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.apply(this, arguments);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.apply(this, arguments);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.apply(this, arguments);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.apply(this, arguments);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.apply(this, arguments);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.apply(this, arguments);\n            };\n        default:\n            throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n        }\n    };\n\n    var _cloneRegExp = function _cloneRegExp(pattern) {\n        return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n    };\n\n    var _complement = function _complement(f) {\n        return function () {\n            return !f.apply(this, arguments);\n        };\n    };\n\n    /**\n     * Private `concat` function to merge two array-like objects.\n     *\n     * @private\n     * @param {Array|Arguments} [set1=[]] An array-like object.\n     * @param {Array|Arguments} [set2=[]] An array-like object.\n     * @return {Array} A new, merged array.\n     * @example\n     *\n     *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     */\n    var _concat = function _concat(set1, set2) {\n        set1 = set1 || [];\n        set2 = set2 || [];\n        var idx;\n        var len1 = set1.length;\n        var len2 = set2.length;\n        var result = [];\n        idx = 0;\n        while (idx < len1) {\n            result[result.length] = set1[idx];\n            idx += 1;\n        }\n        idx = 0;\n        while (idx < len2) {\n            result[result.length] = set2[idx];\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _containsWith = function _containsWith(pred, x, list) {\n        var idx = 0, len = list.length;\n        while (idx < len) {\n            if (pred(x, list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry1 = function _curry1(fn) {\n        return function f1(a) {\n            if (arguments.length === 0) {\n                return f1;\n            } else if (a != null && a['@@functional/placeholder'] === true) {\n                return f1;\n            } else {\n                return fn.apply(this, arguments);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal two-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry2 = function _curry2(fn) {\n        return function f2(a, b) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f2;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 1) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f2;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b);\n                });\n            } else {\n                return fn(a, b);\n            }\n        };\n    };\n\n    /**\n     * Optimized internal three-arity curry function.\n     *\n     * @private\n     * @category Function\n     * @param {Function} fn The function to curry.\n     * @return {Function} The curried function.\n     */\n    var _curry3 = function _curry3(fn) {\n        return function f3(a, b, c) {\n            var n = arguments.length;\n            if (n === 0) {\n                return f3;\n            } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 1) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 2) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return f3;\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && b != null && b['@@functional/placeholder'] === true) {\n                return _curry2(function (a, b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (a, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true && c != null && c['@@functional/placeholder'] === true) {\n                return _curry2(function (b, c) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n                return _curry1(function (a) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n                return _curry1(function (b) {\n                    return fn(a, b, c);\n                });\n            } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n                return _curry1(function (c) {\n                    return fn(a, b, c);\n                });\n            } else {\n                return fn(a, b, c);\n            }\n        };\n    };\n\n    /**\n     * Internal curryN function.\n     *\n     * @private\n     * @category Function\n     * @param {Number} length The arity of the curried function.\n     * @return {array} An array of arguments received thus far.\n     * @param {Function} fn The function to curry.\n     */\n    var _curryN = function _curryN(length, received, fn) {\n        return function () {\n            var combined = [];\n            var argsIdx = 0;\n            var left = length;\n            var combinedIdx = 0;\n            while (combinedIdx < received.length || argsIdx < arguments.length) {\n                var result;\n                if (combinedIdx < received.length && (received[combinedIdx] == null || received[combinedIdx]['@@functional/placeholder'] !== true || argsIdx >= arguments.length)) {\n                    result = received[combinedIdx];\n                } else {\n                    result = arguments[argsIdx];\n                    argsIdx += 1;\n                }\n                combined[combinedIdx] = result;\n                if (result == null || result['@@functional/placeholder'] !== true) {\n                    left -= 1;\n                }\n                combinedIdx += 1;\n            }\n            return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n        };\n    };\n\n    var _filter = function _filter(fn, list) {\n        var idx = 0, len = list.length, result = [];\n        while (idx < len) {\n            if (fn(list[idx])) {\n                result[result.length] = list[idx];\n            }\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _forceReduced = function _forceReduced(x) {\n        return {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * @private\n     * @param {Function} fn The strategy for extracting function names from an object\n     * @return {Function} A function that takes an object and returns an array of function names.\n     */\n    var _functionsWith = function _functionsWith(fn) {\n        return function (obj) {\n            return _filter(function (key) {\n                return typeof obj[key] === 'function';\n            }, fn(obj));\n        };\n    };\n\n    var _has = function _has(prop, obj) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    };\n\n    var _identity = function _identity(x) {\n        return x;\n    };\n\n    /**\n     * Tests whether or not an object is an array.\n     *\n     * @private\n     * @param {*} val The object to test.\n     * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n     * @example\n     *\n     *      _isArray([]); //=> true\n     *      _isArray(null); //=> false\n     *      _isArray({}); //=> false\n     */\n    var _isArray = Array.isArray || function _isArray(val) {\n        return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n    };\n\n    /**\n     * Determine if the passed argument is an integer.\n     *\n     * @private\n     * @param {*} n\n     * @category Type\n     * @return {Boolean}\n     */\n    var _isInteger = Number.isInteger || function _isInteger(n) {\n        return n << 0 === n;\n    };\n\n    var _isNumber = function _isNumber(x) {\n        return Object.prototype.toString.call(x) === '[object Number]';\n    };\n\n    var _isString = function _isString(x) {\n        return Object.prototype.toString.call(x) === '[object String]';\n    };\n\n    var _isTransformer = function _isTransformer(obj) {\n        return typeof obj['@@transducer/step'] === 'function';\n    };\n\n    var _map = function _map(fn, list) {\n        var idx = 0, len = list.length, result = Array(len);\n        while (idx < len) {\n            result[idx] = fn(list[idx]);\n            idx += 1;\n        }\n        return result;\n    };\n\n    var _pipe = function _pipe(f, g) {\n        return function () {\n            return g.call(this, f.apply(this, arguments));\n        };\n    };\n\n    var _pipeP = function _pipeP(f, g) {\n        return function () {\n            var ctx = this;\n            return f.apply(ctx, arguments).then(function (x) {\n                return g.call(ctx, x);\n            });\n        };\n    };\n\n    var _quote = function _quote(s) {\n        return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n    };\n\n    var _reduced = function _reduced(x) {\n        return x && x['@@transducer/reduced'] ? x : {\n            '@@transducer/value': x,\n            '@@transducer/reduced': true\n        };\n    };\n\n    /**\n     * An optimized, private array `slice` implementation.\n     *\n     * @private\n     * @param {Arguments|Array} args The array or arguments object to consider.\n     * @param {Number} [from=0] The array index to slice from, inclusive.\n     * @param {Number} [to=args.length] The array index to slice to, exclusive.\n     * @return {Array} A new, sliced array.\n     * @example\n     *\n     *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n     *\n     *      var firstThreeArgs = function(a, b, c, d) {\n     *        return _slice(arguments, 0, 3);\n     *      };\n     *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n     */\n    var _slice = function _slice(args, from, to) {\n        switch (arguments.length) {\n        case 1:\n            return _slice(args, 0, args.length);\n        case 2:\n            return _slice(args, from, args.length);\n        default:\n            var list = [];\n            var idx = 0;\n            var len = Math.max(0, Math.min(args.length, to) - from);\n            while (idx < len) {\n                list[idx] = args[from + idx];\n                idx += 1;\n            }\n            return list;\n        }\n    };\n\n    /**\n     * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n     */\n    var _toISOString = function () {\n        var pad = function pad(n) {\n            return (n < 10 ? '0' : '') + n;\n        };\n        return typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n            return d.toISOString();\n        } : function _toISOString(d) {\n            return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n        };\n    }();\n\n    var _xdropRepeatsWith = function () {\n        function XDropRepeatsWith(pred, xf) {\n            this.xf = xf;\n            this.pred = pred;\n            this.lastValue = undefined;\n            this.seenFirstValue = false;\n        }\n        XDropRepeatsWith.prototype['@@transducer/init'] = function () {\n            return this.xf['@@transducer/init']();\n        };\n        XDropRepeatsWith.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](result);\n        };\n        XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n            var sameAsLast = false;\n            if (!this.seenFirstValue) {\n                this.seenFirstValue = true;\n            } else if (this.pred(this.lastValue, input)) {\n                sameAsLast = true;\n            }\n            this.lastValue = input;\n            return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropRepeatsWith(pred, xf) {\n            return new XDropRepeatsWith(pred, xf);\n        });\n    }();\n\n    var _xfBase = {\n        init: function () {\n            return this.xf['@@transducer/init']();\n        },\n        result: function (result) {\n            return this.xf['@@transducer/result'](result);\n        }\n    };\n\n    var _xfilter = function () {\n        function XFilter(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFilter.prototype['@@transducer/init'] = _xfBase.init;\n        XFilter.prototype['@@transducer/result'] = _xfBase.result;\n        XFilter.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n        };\n        return _curry2(function _xfilter(f, xf) {\n            return new XFilter(f, xf);\n        });\n    }();\n\n    var _xfind = function () {\n        function XFind(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.found = false;\n        }\n        XFind.prototype['@@transducer/init'] = _xfBase.init;\n        XFind.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, void 0);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFind.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, input));\n            }\n            return result;\n        };\n        return _curry2(function _xfind(f, xf) {\n            return new XFind(f, xf);\n        });\n    }();\n\n    var _xfindIndex = function () {\n        function XFindIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.found = false;\n        }\n        XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindIndex.prototype['@@transducer/result'] = function (result) {\n            if (!this.found) {\n                result = this.xf['@@transducer/step'](result, -1);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.found = true;\n                result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n            }\n            return result;\n        };\n        return _curry2(function _xfindIndex(f, xf) {\n            return new XFindIndex(f, xf);\n        });\n    }();\n\n    var _xfindLast = function () {\n        function XFindLast(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLast.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n        };\n        XFindLast.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.last = input;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLast(f, xf) {\n            return new XFindLast(f, xf);\n        });\n    }();\n\n    var _xfindLastIndex = function () {\n        function XFindLastIndex(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.idx = -1;\n            this.lastIdx = -1;\n        }\n        XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n        XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n            return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n        };\n        XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n            this.idx += 1;\n            if (this.f(input)) {\n                this.lastIdx = this.idx;\n            }\n            return result;\n        };\n        return _curry2(function _xfindLastIndex(f, xf) {\n            return new XFindLastIndex(f, xf);\n        });\n    }();\n\n    var _xmap = function () {\n        function XMap(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XMap.prototype['@@transducer/init'] = _xfBase.init;\n        XMap.prototype['@@transducer/result'] = _xfBase.result;\n        XMap.prototype['@@transducer/step'] = function (result, input) {\n            return this.xf['@@transducer/step'](result, this.f(input));\n        };\n        return _curry2(function _xmap(f, xf) {\n            return new XMap(f, xf);\n        });\n    }();\n\n    var _xtake = function () {\n        function XTake(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XTake.prototype['@@transducer/init'] = _xfBase.init;\n        XTake.prototype['@@transducer/result'] = _xfBase.result;\n        XTake.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n === 0) {\n                return _reduced(result);\n            } else {\n                this.n -= 1;\n                return this.xf['@@transducer/step'](result, input);\n            }\n        };\n        return _curry2(function _xtake(n, xf) {\n            return new XTake(n, xf);\n        });\n    }();\n\n    var _xtakeWhile = function () {\n        function XTakeWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n            return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n        };\n        return _curry2(function _xtakeWhile(f, xf) {\n            return new XTakeWhile(f, xf);\n        });\n    }();\n\n    var _xwrap = function () {\n        function XWrap(fn) {\n            this.f = fn;\n        }\n        XWrap.prototype['@@transducer/init'] = function () {\n            throw new Error('init not implemented on XWrap');\n        };\n        XWrap.prototype['@@transducer/result'] = function (acc) {\n            return acc;\n        };\n        XWrap.prototype['@@transducer/step'] = function (acc, x) {\n            return this.f(acc, x);\n        };\n        return function _xwrap(fn) {\n            return new XWrap(fn);\n        };\n    }();\n\n    /**\n     * Adds two numbers. Equivalent to `a + b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Number}\n     * @see R.subtract\n     * @example\n     *\n     *      R.add(2, 3);       //=>  5\n     *      R.add(7)(10);      //=> 17\n     */\n    var add = _curry2(function add(a, b) {\n        return a + b;\n    });\n\n    /**\n     * Applies a function to the value at the given index of an array,\n     * returning a new copy of the array with the element at the given\n     * index replaced with the result of the function application.\n     * @see R.update\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> a) -> Number -> [a] -> [a]\n     * @param {Function} fn The function to apply.\n     * @param {Number} idx The index.\n     * @param {Array|Arguments} list An array-like object whose value\n     *        at the supplied index will be replaced.\n     * @return {Array} A copy of the supplied array-like object with\n     *         the element at index `idx` replaced with the value\n     *         returned by applying `fn` to the existing element.\n     * @example\n     *\n     *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var adjust = _curry3(function adjust(fn, idx, list) {\n        if (idx >= list.length || idx < -list.length) {\n            return list;\n        }\n        var start = idx < 0 ? list.length : 0;\n        var _idx = start + idx;\n        var _list = _concat(list);\n        _list[_idx] = fn(list[_idx]);\n        return _list;\n    });\n\n    /**\n     * Returns a function that always returns the given value. Note that for\n     * non-primitives the value returned is a reference to the original value.\n     *\n     * This function is known as `const`, `constant`, or `K` (for K combinator)\n     * in other languages and libraries.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> (* -> a)\n     * @param {*} val The value to wrap in a function\n     * @return {Function} A Function :: * -> val.\n     * @example\n     *\n     *      var t = R.always('Tee');\n     *      t(); //=> 'Tee'\n     */\n    var always = _curry1(function always(val) {\n        return function () {\n            return val;\n        };\n    });\n\n    /**\n     * Returns a new list, composed of n-tuples of consecutive elements\n     * If `n` is greater than the length of the list, an empty list is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @param {Number} n The size of the tuples to create\n     * @param {Array} list The list to split into `n`-tuples\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n     *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n     *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n     */\n    var aperture = _curry2(function aperture(n, list) {\n        var idx = 0;\n        var limit = list.length - (n - 1);\n        var acc = new Array(limit >= 0 ? limit : 0);\n        while (idx < limit) {\n            acc[idx] = _slice(list, idx, idx + n);\n            idx += 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a new list containing the contents of the given list, followed by the given\n     * element.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The element to add to the end of the new list.\n     * @param {Array} list The list whose contents will be added to the beginning of the output\n     *        list.\n     * @return {Array} A new list containing the contents of the old list followed by `el`.\n     * @see R.prepend\n     * @example\n     *\n     *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n     *      R.append('tests', []); //=> ['tests']\n     *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n     */\n    var append = _curry2(function append(el, list) {\n        return _concat(list, [el]);\n    });\n\n    /**\n     * Applies function `fn` to the argument list `args`. This is useful for\n     * creating a fixed-arity function from a variadic function. `fn` should\n     * be a bound function if context is significant.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> [*] -> a\n     * @param {Function} fn\n     * @param {Array} args\n     * @return {*}\n     * @see R.call, R.unapply\n     * @example\n     *\n     *      var nums = [1, 2, 3, -99, 42, 6, 7];\n     *      R.apply(Math.max, nums); //=> 42\n     */\n    var apply = _curry2(function apply(fn, args) {\n        return fn.apply(this, args);\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the specified\n     * property with the given value.  Note that this copies and flattens\n     * prototype properties onto the new object as well.  All non-primitive\n     * properties are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {k: v} -> {k: v}\n     * @param {String} prop the property name to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except for the specified property.\n     * @see R.dissoc\n     * @example\n     *\n     *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n     */\n    var assoc = _curry3(function assoc(prop, val, obj) {\n        var result = {};\n        for (var p in obj) {\n            result[p] = obj[p];\n        }\n        result[prop] = val;\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, setting or overriding the nodes\n     * required to create the given path, and placing the specific value at the\n     * tail end of that path.  Note that this copies and flattens prototype\n     * properties onto the new object as well.  All non-primitive properties\n     * are copied by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> a -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {*} val the new value\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original except along the specified path.\n     * @see R.dissocPath\n     * @example\n     *\n     *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n     */\n    var assocPath = _curry3(function assocPath(path, val, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return assoc(path[0], val, obj);\n        default:\n            return assoc(path[0], assocPath(_slice(path, 1), val, Object(obj[path[0]])), obj);\n        }\n    });\n\n    /**\n     * Creates a function that is bound to a context.\n     * Note: `R.bind` does not provide the additional argument-binding capabilities of\n     * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category Object\n     * @see R.partial\n     * @sig (* -> *) -> {*} -> (* -> *)\n     * @param {Function} fn The function to bind to context\n     * @param {Object} thisObj The context to bind `fn` to\n     * @return {Function} A function that will execute in the context of `thisObj`.\n     */\n    var bind = _curry2(function bind(fn, thisObj) {\n        return _arity(fn.length, function () {\n            return fn.apply(thisObj, arguments);\n        });\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\n     * function if it is false-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a false-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n     * @see R.and\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.both(gt10, even);\n     *      f(100); //=> true\n     *      f(101); //=> false\n     */\n    var both = _curry2(function both(f, g) {\n        return function _both() {\n            return f.apply(this, arguments) && g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Makes a comparator function out of a function that reports whether the first element is less than the second.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a, b -> Boolean) -> (a, b -> Number)\n     * @param {Function} pred A predicate function of arity two.\n     * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`.\n     * @example\n     *\n     *      var cmp = R.comparator(function(a, b) {\n     *        return a.age < b.age;\n     *      });\n     *      var people = [\n     *        // ...\n     *      ];\n     *      R.sort(cmp, people);\n     */\n    var comparator = _curry1(function comparator(pred) {\n        return function (a, b) {\n            return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n        };\n    });\n\n    /**\n     * Takes a function `f` and returns a function `g` such that:\n     *\n     *   - applying `g` to zero or more arguments will give __true__ if applying\n     *     the same arguments to `f` gives a logical __false__ value; and\n     *\n     *   - applying `g` to zero or more arguments will give __false__ if applying\n     *     the same arguments to `f` gives a logical __true__ value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> *) -> (*... -> Boolean)\n     * @param {Function} f\n     * @return {Function}\n     * @see R.not\n     * @example\n     *\n     *      var isEven = function(n) { return n % 2 === 0; };\n     *      var isOdd = R.complement(isEven);\n     *      isOdd(21); //=> true\n     *      isOdd(42); //=> false\n     */\n    var complement = _curry1(_complement);\n\n    /**\n     * Returns a function, `fn`, which encapsulates if/else-if/else logic.\n     * `R.cond` takes a list of [predicate, transform] pairs. All of the\n     * arguments to `fn` are applied to each of the predicates in turn\n     * until one returns a \"truthy\" value, at which point `fn` returns the\n     * result of applying its arguments to the corresponding transformer.\n     * If none of the predicates matches, `fn` returns undefined.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n     * @param {Array} pairs\n     * @return {Function}\n     * @example\n     *\n     *      var fn = R.cond([\n     *        [R.equals(0),   R.always('water freezes at 0°C')],\n     *        [R.equals(100), R.always('water boils at 100°C')],\n     *        [R.T,           function(temp) { return 'nothing special happens at ' + temp + '°C'; }]\n     *      ]);\n     *      fn(0); //=> 'water freezes at 0°C'\n     *      fn(50); //=> 'nothing special happens at 50°C'\n     *      fn(100); //=> 'water boils at 100°C'\n     */\n    var cond = _curry1(function cond(pairs) {\n        return function () {\n            var idx = 0;\n            while (idx < pairs.length) {\n                if (pairs[idx][0].apply(this, arguments)) {\n                    return pairs[idx][1].apply(this, arguments);\n                }\n                idx += 1;\n            }\n        };\n    });\n\n    /**\n     * Returns `true` if the `x` is found in the `list`, using `pred` as an\n     * equality predicate for `x`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> a -> [a] -> Boolean\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {*} x The item to find\n     * @param {Array} list The list to iterate over\n     * @return {Boolean} `true` if `x` is in `list`, else `false`.\n     * @example\n     *\n     *      var xs = [{x: 12}, {x: 11}, {x: 10}];\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 10}, xs); //=> true\n     *      R.containsWith(function(a, b) { return a.x === b.x; }, {x: 1}, xs); //=> false\n     */\n    var containsWith = _curry3(_containsWith);\n\n    /**\n     * Counts the elements of a list according to how many match each value\n     * of a key generated by the supplied function. Returns an object\n     * mapping the keys produced by `fn` to the number of occurrences in\n     * the list. Note that all keys are coerced to strings because of how\n     * JavaScript objects work.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a -> String) -> [a] -> {*}\n     * @param {Function} fn The function used to map values to keys.\n     * @param {Array} list The list to count elements from.\n     * @return {Object} An object mapping keys to number of occurrences in the list.\n     * @example\n     *\n     *      var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n     *      var letters = R.split('', 'abcABCaaaBBc');\n     *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n     *      R.countBy(R.toLower)(letters);   //=> {'a': 5, 'b': 4, 'c': 3}\n     */\n    var countBy = _curry2(function countBy(fn, list) {\n        var counts = {};\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            var key = fn(list[idx]);\n            counts[key] = (_has(key, counts) ? counts[key] : 0) + 1;\n            idx += 1;\n        }\n        return counts;\n    });\n\n    /**\n     * Creates an object containing a single key:value pair.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> a -> {String:a}\n     * @param {String} key\n     * @param {*} val\n     * @return {Object}\n     * @example\n     *\n     *      var matchPhrases = R.compose(\n     *        R.createMapEntry('must'),\n     *        R.map(R.createMapEntry('match_phrase'))\n     *      );\n     *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n     */\n    var createMapEntry = _curry2(function createMapEntry(key, val) {\n        var obj = {};\n        obj[key] = val;\n        return obj;\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function, with the\n     * specified arity. The curried function has two unusual capabilities.\n     * First, its arguments needn't be provided one at a time. If `g` is\n     * `R.curryN(3, f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFourNumbers = function() {\n     *        return R.sum([].slice.call(arguments, 0, 4));\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curryN = _curry2(function curryN(length, fn) {\n        if (length === 1) {\n            return _curry1(fn);\n        }\n        return _arity(length, _curryN(length, [], fn));\n    });\n\n    /**\n     * Decrements its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.inc\n     * @example\n     *\n     *      R.dec(42); //=> 41\n     */\n    var dec = add(-1);\n\n    /**\n     * Returns the second argument if it is not null or undefined. If it is null\n     * or undefined, the first (default) argument is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig a -> b -> a | b\n     * @param {a} val The default value.\n     * @param {b} val The value to return if it is not null or undefined\n     * @return {*} The the second value or the default value\n     * @example\n     *\n     *      var defaultTo42 = defaultTo(42);\n     *\n     *      defaultTo42(null);  //=> 42\n     *      defaultTo42(undefined);  //=> 42\n     *      defaultTo42('Ramda');  //=> 'Ramda'\n     */\n    var defaultTo = _curry2(function defaultTo(d, v) {\n        return v == null ? d : v;\n    });\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     * Duplication is determined according to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.difference\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n     *      var l2 = [{a: 3}, {a: 4}];\n     *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n     */\n    var differenceWith = _curry3(function differenceWith(pred, first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        var containsPred = containsWith(pred);\n        while (idx < firstLen) {\n            if (!containsPred(first[idx], second) && !containsPred(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object that does not contain a `prop` property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig String -> {k: v} -> {k: v}\n     * @param {String} prop the name of the property to dissociate\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object similar to the original but without the specified property\n     * @see R.assoc\n     * @example\n     *\n     *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n     */\n    var dissoc = _curry2(function dissoc(prop, obj) {\n        var result = {};\n        for (var p in obj) {\n            if (p !== prop) {\n                result[p] = obj[p];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Makes a shallow clone of an object, omitting the property at the\n     * given path. Note that this copies and flattens prototype properties\n     * onto the new object as well.  All non-primitive properties are copied\n     * by reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> {k: v}\n     * @param {Array} path the path to set\n     * @param {Object} obj the object to clone\n     * @return {Object} a new object without the property at path\n     * @see R.assocPath\n     * @example\n     *\n     *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n     */\n    var dissocPath = _curry2(function dissocPath(path, obj) {\n        switch (path.length) {\n        case 0:\n            return obj;\n        case 1:\n            return dissoc(path[0], obj);\n        default:\n            var head = path[0];\n            var tail = _slice(path, 1);\n            return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);\n        }\n    });\n\n    /**\n     * Divides two numbers. Equivalent to `a / b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a / b`.\n     * @see R.multiply\n     * @example\n     *\n     *      R.divide(71, 100); //=> 0.71\n     *\n     *      var half = R.divide(R.__, 2);\n     *      half(42); //=> 21\n     *\n     *      var reciprocal = R.divide(1);\n     *      reciprocal(4);   //=> 0.25\n     */\n    var divide = _curry2(function divide(a, b) {\n        return a / b;\n    });\n\n    /**\n     * Returns a new list containing all but last the`n` elements of a given list,\n     * passing each value from the right to the supplied predicate function, skipping\n     * elements while the predicate function returns `true`. The predicate function\n     * is passed one argument: (value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeLastWhile\n     * @example\n     *\n     *      var lteThree = function(x) {\n     *        return x <= 3;\n     *      };\n     *\n     *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2]\n     */\n    var dropLastWhile = _curry2(function dropLastWhile(pred, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && pred(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, 0, idx + 1);\n    });\n\n    /**\n     * A function wrapping calls to the two functions in an `||` operation, returning the result of the first\n     * function if it is truth-y and the result of the second function otherwise.  Note that this is\n     * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y\n     * value.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n     * @param {Function} f a predicate\n     * @param {Function} g another predicate\n     * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n     * @see R.or\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0 };\n     *      var f = R.either(gt10, even);\n     *      f(101); //=> true\n     *      f(8); //=> true\n     */\n    var either = _curry2(function either(f, g) {\n        return function _either() {\n            return f.apply(this, arguments) || g.apply(this, arguments);\n        };\n    });\n\n    /**\n     * Returns the empty value of its argument's type. Ramda defines the empty\n     * value of Array (`[]`), Object (`{}`), and String (`''`). Other types are\n     * supported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x\n     * @return {*}\n     * @example\n     *\n     *      R.empty(Just(42));      //=> Nothing()\n     *      R.empty([1, 2, 3]);     //=> []\n     *      R.empty('unicorns');    //=> ''\n     *      R.empty({x: 1, y: 2});  //=> {}\n     */\n    var empty = _curry1(function empty(x) {\n        if (x != null && typeof x.empty === 'function') {\n            return x.empty();\n        } else if (x != null && typeof x.constructor != null && typeof x.constructor.empty === 'function') {\n            return x.constructor.empty();\n        } else {\n            switch (Object.prototype.toString.call(x)) {\n            case '[object Array]':\n                return [];\n            case '[object Object]':\n                return {};\n            case '[object String]':\n                return '';\n            }\n        }\n    });\n\n    /**\n     * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n     * `transformation` functions. All non-primitive properties are copied by reference.\n     *\n     * A `tranformation` function will not be invoked if its corresponding key does not exist in\n     * the evolved object.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n     * @param {Object} transformations The object specifying transformation functions to apply\n     *        to the object.\n     * @param {Object} object The object to be transformed.\n     * @return {Object} The transformed object.\n     * @example\n     *\n     *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n     *      var transformations = {\n     *        firstName: R.trim,\n     *        lastName: R.trim, // Will not get invoked.\n     *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n     *      };\n     *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n     */\n    var evolve = _curry2(function evolve(transformations, object) {\n        var transformation, key, type, result = {};\n        for (key in object) {\n            transformation = transformations[key];\n            type = typeof transformation;\n            result[key] = type === 'function' ? transformation(object[key]) : type === 'object' ? evolve(transformations[key], object[key]) : object[key];\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new object out of a list key-value pairs.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [[k,v]] -> {k: v}\n     * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n     * @return {Object} The object made by pairing up `keys` and `values`.\n     * @see R.toPairs\n     * @example\n     *\n     *      R.fromPairs([['a', 1], ['b', 2],  ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n     */\n    var fromPairs = _curry1(function fromPairs(pairs) {\n        var idx = 0, len = pairs.length, out = {};\n        while (idx < len) {\n            if (_isArray(pairs[idx]) && pairs[idx].length) {\n                out[pairs[idx][0]] = pairs[idx][1];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.lt\n     * @example\n     *\n     *      R.gt(2, 1); //=> true\n     *      R.gt(2, 2); //=> false\n     *      R.gt(2, 3); //=> false\n     *      R.gt('a', 'z'); //=> false\n     *      R.gt('z', 'a'); //=> true\n     */\n    var gt = _curry2(function gt(a, b) {\n        return a > b;\n    });\n\n    /**\n     * Returns `true` if the first argument is greater than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.lte\n     * @example\n     *\n     *      R.gte(2, 1); //=> true\n     *      R.gte(2, 2); //=> true\n     *      R.gte(2, 3); //=> false\n     *      R.gte('a', 'z'); //=> false\n     *      R.gte('z', 'a'); //=> true\n     */\n    var gte = _curry2(function gte(a, b) {\n        return a >= b;\n    });\n\n    /**\n     * Returns whether or not an object has an own property with\n     * the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      var hasName = R.has('name');\n     *      hasName({name: 'alice'});   //=> true\n     *      hasName({name: 'bob'});     //=> true\n     *      hasName({});                //=> false\n     *\n     *      var point = {x: 0, y: 0};\n     *      var pointHas = R.has(R.__, point);\n     *      pointHas('x');  //=> true\n     *      pointHas('y');  //=> true\n     *      pointHas('z');  //=> false\n     */\n    var has = _curry2(_has);\n\n    /**\n     * Returns whether or not an object or its prototype chain has\n     * a property with the specified name\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: x} -> Boolean\n     * @param {String} prop The name of the property to check for.\n     * @param {Object} obj The object to query.\n     * @return {Boolean} Whether the property exists.\n     * @example\n     *\n     *      function Rectangle(width, height) {\n     *        this.width = width;\n     *        this.height = height;\n     *      }\n     *      Rectangle.prototype.area = function() {\n     *        return this.width * this.height;\n     *      };\n     *\n     *      var square = new Rectangle(2, 2);\n     *      R.hasIn('width', square);  //=> true\n     *      R.hasIn('area', square);  //=> true\n     */\n    var hasIn = _curry2(function hasIn(prop, obj) {\n        return prop in obj;\n    });\n\n    /**\n     * Returns true if its arguments are identical, false otherwise. Values are\n     * identical if they reference the same memory. `NaN` is identical to `NaN`;\n     * `0` and `-0` are not identical.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      var o = {};\n     *      R.identical(o, o); //=> true\n     *      R.identical(1, 1); //=> true\n     *      R.identical(1, '1'); //=> false\n     *      R.identical([], []); //=> false\n     *      R.identical(0, -0); //=> false\n     *      R.identical(NaN, NaN); //=> true\n     */\n    // SameValue algorithm\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    // Step 6.a: NaN == NaN\n    var identical = _curry2(function identical(a, b) {\n        // SameValue algorithm\n        if (a === b) {\n            // Steps 1-5, 7-10\n            // Steps 6.b-6.e: +0 != -0\n            return a !== 0 || 1 / a === 1 / b;\n        } else {\n            // Step 6.a: NaN == NaN\n            return a !== a && b !== b;\n        }\n    });\n\n    /**\n     * A function that does nothing but return the parameter supplied to it. Good as a default\n     * or placeholder function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> a\n     * @param {*} x The value to return.\n     * @return {*} The input value, `x`.\n     * @example\n     *\n     *      R.identity(1); //=> 1\n     *\n     *      var obj = {};\n     *      R.identity(obj) === obj; //=> true\n     */\n    var identity = _curry1(_identity);\n\n    /**\n     * Creates a function that will process either the `onTrue` or the `onFalse` function depending\n     * upon the result of the `condition` predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n     * @param {Function} condition A predicate function\n     * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n     * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n     * @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`\n     *                    function depending upon the result of the `condition` predicate.\n     * @example\n     *\n     *      // Flatten all arrays in the list but leave other values alone.\n     *      var flattenArrays = R.map(R.ifElse(Array.isArray, R.flatten, R.identity));\n     *\n     *      flattenArrays([[0], [[10], [8]], 1234, {}]); //=> [[0], [10, 8], 1234, {}]\n     *      flattenArrays([[[10], 123], [8, [10]], \"hello\"]); //=> [[10, 123], [8, 10], \"hello\"]\n     */\n    var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) {\n        return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n            return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n        });\n    });\n\n    /**\n     * Increments its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @see R.dec\n     * @example\n     *\n     *      R.inc(42); //=> 43\n     */\n    var inc = add(1);\n\n    /**\n     * Inserts the supplied element into the list, at index `index`.  _Note\n     * that this is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} index The position to insert the element\n     * @param {*} elt The element to insert into the Array\n     * @param {Array} list The list to insert into\n     * @return {Array} A new Array with `elt` inserted at `index`.\n     * @example\n     *\n     *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n     */\n    var insert = _curry3(function insert(idx, elt, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        var result = _slice(list);\n        result.splice(idx, 0, elt);\n        return result;\n    });\n\n    /**\n     * Inserts the sub-list into the list, at index `index`.  _Note  that this\n     * is not destructive_: it returns a copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a] -> [a]\n     * @param {Number} index The position to insert the sub-list\n     * @param {Array} elts The sub-list to insert into the Array\n     * @param {Array} list The list to insert the sub-list into\n     * @return {Array} A new Array with `elts` inserted starting at `index`.\n     * @example\n     *\n     *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n     */\n    var insertAll = _curry3(function insertAll(idx, elts, list) {\n        idx = idx < list.length && idx >= 0 ? idx : list.length;\n        return _concat(_concat(_slice(list, 0, idx), elts), _slice(list, idx));\n    });\n\n    /**\n     * See if an object (`val`) is an instance of the supplied constructor.\n     * This function will check up the inheritance chain, if any.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> a -> Boolean\n     * @param {Object} ctor A constructor\n     * @param {*} val The value to test\n     * @return {Boolean}\n     * @example\n     *\n     *      R.is(Object, {}); //=> true\n     *      R.is(Number, 1); //=> true\n     *      R.is(Object, 1); //=> false\n     *      R.is(String, 's'); //=> true\n     *      R.is(String, new String('')); //=> true\n     *      R.is(Object, new String('')); //=> true\n     *      R.is(Object, 's'); //=> false\n     *      R.is(Number, {}); //=> false\n     */\n    var is = _curry2(function is(Ctor, val) {\n        return val != null && val.constructor === Ctor || val instanceof Ctor;\n    });\n\n    /**\n     * Tests whether or not an object is similar to an array.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @category List\n     * @sig * -> Boolean\n     * @param {*} x The object to test.\n     * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n     * @example\n     *\n     *      R.isArrayLike([]); //=> true\n     *      R.isArrayLike(true); //=> false\n     *      R.isArrayLike({}); //=> false\n     *      R.isArrayLike({length: 10}); //=> false\n     *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n     */\n    var isArrayLike = _curry1(function isArrayLike(x) {\n        if (_isArray(x)) {\n            return true;\n        }\n        if (!x) {\n            return false;\n        }\n        if (typeof x !== 'object') {\n            return false;\n        }\n        if (x instanceof String) {\n            return false;\n        }\n        if (x.nodeType === 1) {\n            return !!x.length;\n        }\n        if (x.length === 0) {\n            return true;\n        }\n        if (x.length > 0) {\n            return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n        }\n        return false;\n    });\n\n    /**\n     * Reports whether the list has zero elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [a] -> Boolean\n     * @param {Array} list\n     * @return {Boolean}\n     * @example\n     *\n     *      R.isEmpty([1, 2, 3]);   //=> false\n     *      R.isEmpty([]);          //=> true\n     *      R.isEmpty('');          //=> true\n     *      R.isEmpty(null);        //=> false\n     *      R.isEmpty(R.keys({}));  //=> true\n     *      R.isEmpty({});          //=> false ({} does not have a length property)\n     *      R.isEmpty({length: 0}); //=> true\n     */\n    var isEmpty = _curry1(function isEmpty(list) {\n        return Object(list).length === 0;\n    });\n\n    /**\n     * Checks if the input value is `null` or `undefined`.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig * -> Boolean\n     * @param {*} x The value to test.\n     * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n     * @example\n     *\n     *      R.isNil(null); //=> true\n     *      R.isNil(undefined); //=> true\n     *      R.isNil(0); //=> false\n     *      R.isNil([]); //=> false\n     */\n    var isNil = _curry1(function isNil(x) {\n        return x == null;\n    });\n\n    /**\n     * Returns a list containing the names of all the enumerable own\n     * properties of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own properties.\n     * @example\n     *\n     *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n     */\n    // cover IE < 9 keys issues\n    var keys = function () {\n        // cover IE < 9 keys issues\n        var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n        var nonEnumerableProps = [\n            'constructor',\n            'valueOf',\n            'isPrototypeOf',\n            'toString',\n            'propertyIsEnumerable',\n            'hasOwnProperty',\n            'toLocaleString'\n        ];\n        var contains = function contains(list, item) {\n            var idx = 0;\n            while (idx < list.length) {\n                if (list[idx] === item) {\n                    return true;\n                }\n                idx += 1;\n            }\n            return false;\n        };\n        return typeof Object.keys === 'function' ? _curry1(function keys(obj) {\n            return Object(obj) !== obj ? [] : Object.keys(obj);\n        }) : _curry1(function keys(obj) {\n            if (Object(obj) !== obj) {\n                return [];\n            }\n            var prop, ks = [], nIdx;\n            for (prop in obj) {\n                if (_has(prop, obj)) {\n                    ks[ks.length] = prop;\n                }\n            }\n            if (hasEnumBug) {\n                nIdx = nonEnumerableProps.length - 1;\n                while (nIdx >= 0) {\n                    prop = nonEnumerableProps[nIdx];\n                    if (_has(prop, obj) && !contains(ks, prop)) {\n                        ks[ks.length] = prop;\n                    }\n                    nIdx -= 1;\n                }\n            }\n            return ks;\n        });\n    }();\n\n    /**\n     * Returns a list containing the names of all the\n     * properties of the supplied object, including prototype properties.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [k]\n     * @param {Object} obj The object to extract properties from\n     * @return {Array} An array of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.keysIn(f); //=> ['x', 'y']\n     */\n    var keysIn = _curry1(function keysIn(obj) {\n        var prop, ks = [];\n        for (prop in obj) {\n            ks[ks.length] = prop;\n        }\n        return ks;\n    });\n\n    /**\n     * Returns the number of elements in the array by returning `list.length`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Number\n     * @param {Array} list The array to inspect.\n     * @return {Number} The length of the array.\n     * @example\n     *\n     *      R.length([]); //=> 0\n     *      R.length([1, 2, 3]); //=> 3\n     */\n    var length = _curry1(function length(list) {\n        return list != null && is(Number, list.length) ? list.length : NaN;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @see R.gt\n     * @example\n     *\n     *      R.lt(2, 1); //=> false\n     *      R.lt(2, 2); //=> false\n     *      R.lt(2, 3); //=> true\n     *      R.lt('a', 'z'); //=> true\n     *      R.lt('z', 'a'); //=> false\n     */\n    var lt = _curry2(function lt(a, b) {\n        return a < b;\n    });\n\n    /**\n     * Returns `true` if the first argument is less than or equal to the second;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> Boolean\n     * @param {Number} a\n     * @param {Number} b\n     * @return {Boolean}\n     * @see R.gte\n     * @example\n     *\n     *      R.lte(2, 1); //=> false\n     *      R.lte(2, 2); //=> true\n     *      R.lte(2, 3); //=> true\n     *      R.lte('a', 'z'); //=> true\n     *      R.lte('z', 'a'); //=> false\n     */\n    var lte = _curry2(function lte(a, b) {\n        return a <= b;\n    });\n\n    /**\n     * The mapAccum function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from left to\n     * right, and returning a final value of this accumulator together with the new list.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccum(append, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n     */\n    var mapAccum = _curry3(function mapAccum(fn, acc, list) {\n        var idx = 0, len = list.length, result = [], tuple = [acc];\n        while (idx < len) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx += 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * The mapAccumRight function behaves like a combination of map and reduce; it applies a\n     * function to each element of a list, passing an accumulating parameter from right\n     * to left, and returning a final value of this accumulator together with the new list.\n     *\n     * Similar to `mapAccum`, except moves through the input list from the right to the\n     * left.\n     *\n     * The iterator function receives two arguments, *acc* and *value*, and should return\n     * a tuple *[acc, value]*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var digits = ['1', '2', '3', '4'];\n     *      var append = function(a, b) {\n     *        return [a + b, a + b];\n     *      }\n     *\n     *      R.mapAccumRight(append, 0, digits); //=> ['04321', ['04321', '0432', '043', '04']]\n     */\n    var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) {\n        var idx = list.length - 1, result = [], tuple = [acc];\n        while (idx >= 0) {\n            tuple = fn(tuple[0], list[idx]);\n            result[idx] = tuple[1];\n            idx -= 1;\n        }\n        return [\n            tuple[0],\n            result\n        ];\n    });\n\n    /**\n     * Tests a regular expression against a String. Note that this function\n     * will return an empty array when there are no matches. This differs\n     * from [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n     * which returns `null` when there are no matches.\n     *\n     * @func\n     * @memberOf R\n     * @see R.test\n     * @category String\n     * @sig RegExp -> String -> [String | Undefined]\n     * @param {RegExp} rx A regular expression.\n     * @param {String} str The string to match against\n     * @return {Array} The list of matches or empty array.\n     * @example\n     *\n     *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n     *      R.match(/a/, 'b'); //=> []\n     *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n     */\n    var match = _curry2(function match(rx, str) {\n        return str.match(rx) || [];\n    });\n\n    /**\n     * mathMod behaves like the modulo operator should mathematically, unlike the `%`\n     * operator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\n     * mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\n     * when the modulus is zero or negative.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} m The dividend.\n     * @param {Number} p the modulus.\n     * @return {Number} The result of `b mod a`.\n     * @example\n     *\n     *      R.mathMod(-17, 5);  //=> 3\n     *      R.mathMod(17, 5);   //=> 2\n     *      R.mathMod(17, -5);  //=> NaN\n     *      R.mathMod(17, 0);   //=> NaN\n     *      R.mathMod(17.2, 5); //=> NaN\n     *      R.mathMod(17, 5.3); //=> NaN\n     *\n     *      var clock = R.mathMod(R.__, 12);\n     *      clock(15); //=> 3\n     *      clock(24); //=> 0\n     *\n     *      var seventeenMod = R.mathMod(17);\n     *      seventeenMod(3);  //=> 2\n     *      seventeenMod(4);  //=> 1\n     *      seventeenMod(10); //=> 7\n     */\n    var mathMod = _curry2(function mathMod(m, p) {\n        if (!_isInteger(m)) {\n            return NaN;\n        }\n        if (!_isInteger(p) || p < 1) {\n            return NaN;\n        }\n        return (m % p + p) % p;\n    });\n\n    /**\n     * Returns the larger of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.maxBy, R.min\n     * @example\n     *\n     *      R.max(789, 123); //=> 789\n     *      R.max('a', 'b'); //=> 'b'\n     */\n    var max = _curry2(function max(a, b) {\n        return b > a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the larger result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.max, R.minBy\n     * @example\n     *\n     *      R.maxBy(function(n) { return n * n; }, -3, 2); //=> -3\n     */\n    var maxBy = _curry3(function maxBy(f, a, b) {\n        return f(b) > f(a) ? b : a;\n    });\n\n    /**\n     * Create a new object with the own properties of `a`\n     * merged with the own properties of object `b`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> {k: v} -> {k: v}\n     * @param {Object} a\n     * @param {Object} b\n     * @return {Object}\n     * @example\n     *\n     *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n     *      //=> { 'name': 'fred', 'age': 40 }\n     *\n     *      var resetToDefault = R.merge(R.__, {x: 0});\n     *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n     */\n    var merge = _curry2(function merge(a, b) {\n        var result = {};\n        var ks = keys(a);\n        var idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = a[ks[idx]];\n            idx += 1;\n        }\n        ks = keys(b);\n        idx = 0;\n        while (idx < ks.length) {\n            result[ks[idx]] = b[ks[idx]];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the smaller of its two arguments.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord a => a -> a -> a\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.minBy, R.max\n     * @example\n     *\n     *      R.min(789, 123); //=> 123\n     *      R.min('a', 'b'); //=> 'a'\n     */\n    var min = _curry2(function min(a, b) {\n        return b < a ? b : a;\n    });\n\n    /**\n     * Takes a function and two values, and returns whichever value produces\n     * the smaller result when passed to the provided function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> a -> a -> a\n     * @param {Function} f\n     * @param {*} a\n     * @param {*} b\n     * @return {*}\n     * @see R.min, R.maxBy\n     * @example\n     *\n     *      R.minBy(function(n) { return n * n; }, -3, 2); //=> 2\n     */\n    var minBy = _curry3(function minBy(f, a, b) {\n        return f(b) < f(a) ? b : a;\n    });\n\n    /**\n     * Divides the second parameter by the first and returns the remainder.\n     * Note that this functions preserves the JavaScript-style behavior for\n     * modulo. For mathematical modulo see `mathMod`\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The value to the divide.\n     * @param {Number} b The pseudo-modulus\n     * @return {Number} The result of `b % a`.\n     * @see R.mathMod\n     * @example\n     *\n     *      R.modulo(17, 3); //=> 2\n     *      // JS behavior:\n     *      R.modulo(-17, 3); //=> -2\n     *      R.modulo(17, -3); //=> 2\n     *\n     *      var isOdd = R.modulo(R.__, 2);\n     *      isOdd(42); //=> 0\n     *      isOdd(21); //=> 1\n     */\n    var modulo = _curry2(function modulo(a, b) {\n        return a % b;\n    });\n\n    /**\n     * Multiplies two numbers. Equivalent to `a * b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a * b`.\n     * @see R.divide\n     * @example\n     *\n     *      var double = R.multiply(2);\n     *      var triple = R.multiply(3);\n     *      double(3);       //=>  6\n     *      triple(4);       //=> 12\n     *      R.multiply(2, 5);  //=> 10\n     */\n    var multiply = _curry2(function multiply(a, b) {\n        return a * b;\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> a) -> (* -> a)\n     * @param {Number} n The desired arity of the new function.\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity `n`.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.nAry(1, takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only `n` arguments are passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var nAry = _curry2(function nAry(n, fn) {\n        switch (n) {\n        case 0:\n            return function () {\n                return fn.call(this);\n            };\n        case 1:\n            return function (a0) {\n                return fn.call(this, a0);\n            };\n        case 2:\n            return function (a0, a1) {\n                return fn.call(this, a0, a1);\n            };\n        case 3:\n            return function (a0, a1, a2) {\n                return fn.call(this, a0, a1, a2);\n            };\n        case 4:\n            return function (a0, a1, a2, a3) {\n                return fn.call(this, a0, a1, a2, a3);\n            };\n        case 5:\n            return function (a0, a1, a2, a3, a4) {\n                return fn.call(this, a0, a1, a2, a3, a4);\n            };\n        case 6:\n            return function (a0, a1, a2, a3, a4, a5) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5);\n            };\n        case 7:\n            return function (a0, a1, a2, a3, a4, a5, a6) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n            };\n        case 8:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n            };\n        case 9:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n            };\n        case 10:\n            return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n                return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n            };\n        default:\n            throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n        }\n    });\n\n    /**\n     * Negates its argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number\n     * @param {Number} n\n     * @return {Number}\n     * @example\n     *\n     *      R.negate(42); //=> -42\n     */\n    var negate = _curry1(function negate(n) {\n        return -n;\n    });\n\n    /**\n     * A function that returns the `!` of its argument. It will return `true` when\n     * passed false-y value, and `false` when passed a truth-y one.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> Boolean\n     * @param {*} a any value\n     * @return {Boolean} the logical inverse of passed argument.\n     * @see R.complement\n     * @example\n     *\n     *      R.not(true); //=> false\n     *      R.not(false); //=> true\n     *      R.not(0); => true\n     *      R.not(1); => false\n     */\n    var not = _curry1(function not(a) {\n        return !a;\n    });\n\n    /**\n     * Returns the nth element of the given list or string.\n     * If n is negative the element at index length + n is returned.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> a | Undefined\n     * @sig Number -> String -> String\n     * @param {Number} offset\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      var list = ['foo', 'bar', 'baz', 'quux'];\n     *      R.nth(1, list); //=> 'bar'\n     *      R.nth(-1, list); //=> 'quux'\n     *      R.nth(-99, list); //=> undefined\n     *\n     *      R.nth('abc', 2); //=> 'c'\n     *      R.nth('abc', 3); //=> ''\n     */\n    var nth = _curry2(function nth(offset, list) {\n        var idx = offset < 0 ? list.length + offset : offset;\n        return _isString(list) ? list.charAt(idx) : list[idx];\n    });\n\n    /**\n     * Returns a function which returns its nth argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> *... -> *\n     * @param {Number} n\n     * @return {Function}\n     * @example\n     *\n     *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n     *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n     */\n    var nthArg = _curry1(function nthArg(n) {\n        return function () {\n            return nth(n, arguments);\n        };\n    });\n\n    /**\n     * Returns the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {String} str\n     * @return {String}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthChar(2, 'Ramda'); //=> 'm'\n     *      R.nthChar(-2, 'Ramda'); //=> 'd'\n     */\n    var nthChar = _curry2(function nthChar(n, str) {\n        return str.charAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns the character code of the nth character of the given string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig Number -> String -> Number\n     * @param {Number} n\n     * @param {String} str\n     * @return {Number}\n     * @deprecated since v0.16.0\n     * @example\n     *\n     *      R.nthCharCode(2, 'Ramda'); //=> 'm'.charCodeAt(0)\n     *      R.nthCharCode(-2, 'Ramda'); //=> 'd'.charCodeAt(0)\n     */\n    var nthCharCode = _curry2(function nthCharCode(n, str) {\n        return str.charCodeAt(n < 0 ? str.length + n : n);\n    });\n\n    /**\n     * Returns a singleton array containing the value provided.\n     *\n     * Note this `of` is different from the ES6 `of`; See\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig a -> [a]\n     * @param {*} x any value\n     * @return {Array} An array wrapping `x`.\n     * @example\n     *\n     *      R.of(null); //=> [null]\n     *      R.of([42]); //=> [[42]]\n     */\n    var of = _curry1(function of(x) {\n        return [x];\n    });\n\n    /**\n     * Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n     * `fn` can only ever be called once, no matter how many times the returned function is\n     * invoked.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> (a... -> b)\n     * @param {Function} fn The function to wrap in a call-only-once wrapper.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var addOneOnce = R.once(function(x){ return x + 1; });\n     *      addOneOnce(10); //=> 11\n     *      addOneOnce(addOneOnce(50)); //=> 11\n     */\n    var once = _curry1(function once(fn) {\n        var called = false, result;\n        return function () {\n            if (called) {\n                return result;\n            }\n            called = true;\n            result = fn.apply(this, arguments);\n            return result;\n        };\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> (a -> a) -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n     */\n    var over = function () {\n        var Identity = function (x) {\n            return {\n                value: x,\n                map: function (f) {\n                    return Identity(f(x));\n                }\n            };\n        };\n        return _curry3(function over(lens, f, x) {\n            return lens(function (y) {\n                return Identity(f(y));\n            })(x).value;\n        });\n    }();\n\n    /**\n     * Retrieve the value at a given path.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {k: v} -> v | Undefined\n     * @param {Array} path The path to use.\n     * @return {*} The data at `path`.\n     * @example\n     *\n     *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n     *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n     */\n    var path = _curry2(function path(paths, obj) {\n        if (obj == null) {\n            return;\n        } else {\n            var val = obj;\n            for (var idx = 0, len = paths.length; idx < len && val != null; idx += 1) {\n                val = val[paths[idx]];\n            }\n            return val;\n        }\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\n     * property is ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.omit\n     * @example\n     *\n     *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n     */\n    var pick = _curry2(function pick(names, obj) {\n        var result = {};\n        var idx = 0;\n        while (idx < names.length) {\n            if (names[idx] in obj) {\n                result[names[idx]] = obj[names[idx]];\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> {k: v}\n     * @param {Array} names an array of String property names to copy onto a new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties from `names` on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n     *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n     */\n    var pickAll = _curry2(function pickAll(names, obj) {\n        var result = {};\n        var idx = 0;\n        var len = names.length;\n        while (idx < len) {\n            var name = names[idx];\n            result[name] = obj[name];\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a partial copy of an object containing only the keys that\n     * satisfy the supplied predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k -> Boolean) -> {k: v} -> {k: v}\n     * @param {Function} pred A predicate to determine whether or not a key\n     *        should be included on the output object.\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with only properties that satisfy `pred`\n     *         on it.\n     * @see R.pick\n     * @example\n     *\n     *      var isUpperCase = function(val, key) { return key.toUpperCase() === key; }\n     *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n     */\n    var pickBy = _curry2(function pickBy(test, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (test(obj[prop], prop, obj)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list with the given element at the front, followed by the contents of the\n     * list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} el The item to add to the head of the output list.\n     * @param {Array} list The array to add to the tail of the output list.\n     * @return {Array} A new array.\n     * @see R.append\n     * @example\n     *\n     *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n     */\n    var prepend = _curry2(function prepend(el, list) {\n        return _concat([el], list);\n    });\n\n    /**\n     * Returns a function that when supplied an object returns the indicated property of that object, if it exists.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig s -> {s: a} -> a | Undefined\n     * @param {String} p The property name\n     * @param {Object} obj The object to query\n     * @return {*} The value at `obj.p`.\n     * @example\n     *\n     *      R.prop('x', {x: 100}); //=> 100\n     *      R.prop('x', {}); //=> undefined\n     */\n    var prop = _curry2(function prop(p, obj) {\n        return obj[p];\n    });\n\n    /**\n     * If the given, non-null object has an own property with the specified name,\n     * returns the value of that property.\n     * Otherwise returns the provided default value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig a -> String -> Object -> a\n     * @param {*} val The default value.\n     * @param {String} p The name of the property to return.\n     * @param {Object} obj The object to query.\n     * @return {*} The value of given property of the supplied object or the default value.\n     * @example\n     *\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var favorite = R.prop('favoriteLibrary');\n     *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n     *\n     *      favorite(alice);  //=> undefined\n     *      favoriteWithDefault(alice);  //=> 'Ramda'\n     */\n    var propOr = _curry3(function propOr(val, p, obj) {\n        return obj != null && _has(p, obj) ? obj[p] : val;\n    });\n\n    /**\n     * Returns `true` if the specified object property satisfies the given\n     * predicate; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n     * @param {Function} pred\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.propEq\n     * @see R.propIs\n     * @example\n     *\n     *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n     */\n    var propSatisfies = _curry3(function propSatisfies(pred, name, obj) {\n        return pred(obj[name]);\n    });\n\n    /**\n     * Acts as multiple `prop`: array of keys in, array of values out. Preserves order.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [k] -> {k: v} -> [v]\n     * @param {Array} ps The property names to fetch\n     * @param {Object} obj The object to query\n     * @return {Array} The corresponding values or partially applied function.\n     * @example\n     *\n     *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n     *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n     *\n     *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n     *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n     */\n    var props = _curry2(function props(ps, obj) {\n        var len = ps.length;\n        var out = [];\n        var idx = 0;\n        while (idx < len) {\n            out[idx] = obj[ps[idx]];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a list of numbers from `from` (inclusive) to `to`\n     * (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [Number]\n     * @param {Number} from The first number in the list.\n     * @param {Number} to One more than the last number in the list.\n     * @return {Array} The list of numbers in tthe set `[a, b)`.\n     * @example\n     *\n     *      R.range(1, 5);    //=> [1, 2, 3, 4]\n     *      R.range(50, 53);  //=> [50, 51, 52]\n     */\n    var range = _curry2(function range(from, to) {\n        if (!(_isNumber(from) && _isNumber(to))) {\n            throw new TypeError('Both arguments to range must be numbers');\n        }\n        var result = [];\n        var n = from;\n        while (n < to) {\n            result.push(n);\n            n += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * Similar to `reduce`, except moves through the input list from the right to the left.\n     *\n     * The iterator function receives two values: *(acc, value)*\n     *\n     * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var pairs = [ ['a', 1], ['b', 2], ['c', 3] ];\n     *      var flattenPairs = function(acc, pair) {\n     *        return acc.concat(pair);\n     *      };\n     *\n     *      R.reduceRight(flattenPairs, [], pairs); //=> [ 'c', 3, 'b', 2, 'a', 1 ]\n     */\n    var reduceRight = _curry3(function reduceRight(fn, acc, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            acc = fn(acc, list[idx]);\n            idx -= 1;\n        }\n        return acc;\n    });\n\n    /**\n     * Returns a value wrapped to indicate that it is the final value of the\n     * reduce and transduce functions.  The returned value\n     * should be considered a black box: the internal structure is not\n     * guaranteed to be stable.\n     *\n     * Note: this optimization is unavailable to functions not explicitly listed\n     * above.  For instance, it is not currently supported by reduceIndexed,\n     * reduceRight, or reduceRightIndexed.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.transduce\n     * @sig a -> *\n     * @param {*} x The final value of the reduce.\n     * @return {*} The wrapped value.\n     * @example\n     *\n     *      R.reduce(\n     *        R.pipe(R.add, R.ifElse(R.lte(10), R.reduced, R.identity)),\n     *        0,\n     *        [1, 2, 3, 4, 5]) // 10\n     */\n    var reduced = _curry1(_reduced);\n\n    /**\n     * Removes the sub-list of `list` starting at index `start` and containing\n     * `count` elements.  _Note that this is not destructive_: it returns a\n     * copy of the list with the changes.\n     * <small>No lists have been harmed in the application of this function.</small>\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @param {Number} start The position to start removing elements\n     * @param {Number} count The number of elements to remove\n     * @param {Array} list The list to remove from\n     * @return {Array} A new Array with `count` elements from `start` removed.\n     * @example\n     *\n     *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n     */\n    var remove = _curry3(function remove(start, count, list) {\n        return _concat(_slice(list, 0, Math.min(start, list.length)), _slice(list, Math.min(list.length, start + count)));\n    });\n\n    /**\n     * Replace a substring or regex match in a string with a replacement.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig RegExp|String -> String -> String -> String\n     * @param {RegExp|String} pattern A regular expression or a substring to match.\n     * @param {String} replacement The string to replace the matches with.\n     * @param {String} str The String to do the search and replacement in.\n     * @return {String} The result.\n     * @example\n     *\n     *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n     *\n     *      // Use the \"g\" (global) flag to replace all occurrences:\n     *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n     */\n    var replace = _curry3(function replace(regex, replacement, str) {\n        return str.replace(regex, replacement);\n    });\n\n    /**\n     * Returns a new list with the same elements as the original list, just\n     * in the reverse order.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The list to reverse.\n     * @return {Array} A copy of the list in reverse order.\n     * @example\n     *\n     *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n     *      R.reverse([1, 2]);     //=> [2, 1]\n     *      R.reverse([1]);        //=> [1]\n     *      R.reverse([]);         //=> []\n     */\n    var reverse = _curry1(function reverse(list) {\n        return _slice(list).reverse();\n    });\n\n    /**\n     * Scan is similar to reduce, but returns a list of successively reduced values from the left\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> [a]\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} A list of all intermediately reduced values.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n     */\n    var scan = _curry3(function scan(fn, acc, list) {\n        var idx = 0, len = list.length, result = [acc];\n        while (idx < len) {\n            acc = fn(acc, list[idx]);\n            result[idx + 1] = acc;\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns the result of \"setting\" the portion of the given data structure\n     * focused by the given lens to the given value.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> a -> s -> s\n     * @param {Lens} lens\n     * @param {*} v\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n     *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n     */\n    var set = _curry3(function set(lens, v, x) {\n        return over(lens, always(v), x);\n    });\n\n    /**\n     * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\n     * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero\n     * if they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,a -> Number) -> [a] -> [a]\n     * @param {Function} comparator A sorting function :: a -> b -> Int\n     * @param {Array} list The list to sort\n     * @return {Array} a new array with its elements sorted by the comparator function.\n     * @example\n     *\n     *      var diff = function(a, b) { return a - b; };\n     *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n     */\n    var sort = _curry2(function sort(comparator, list) {\n        return _slice(list).sort(comparator);\n    });\n\n    /**\n     * Sorts the list according to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig Ord b => (a -> b) -> [a] -> [a]\n     * @param {Function} fn\n     * @param {Array} list The list to sort.\n     * @return {Array} A new list sorted by the keys generated by `fn`.\n     * @example\n     *\n     *      var sortByFirstItem = R.sortBy(prop(0));\n     *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n     *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n     *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n     *      var alice = {\n     *        name: 'ALICE',\n     *        age: 101\n     *      };\n     *      var bob = {\n     *        name: 'Bob',\n     *        age: -10\n     *      };\n     *      var clara = {\n     *        name: 'clara',\n     *        age: 314.159\n     *      };\n     *      var people = [clara, bob, alice];\n     *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n     */\n    var sortBy = _curry2(function sortBy(fn, list) {\n        return _slice(list).sort(function (a, b) {\n            var aa = fn(a);\n            var bb = fn(b);\n            return aa < bb ? -1 : aa > bb ? 1 : 0;\n        });\n    });\n\n    /**\n     * Subtracts two numbers. Equivalent to `a - b` but curried.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig Number -> Number -> Number\n     * @param {Number} a The first value.\n     * @param {Number} b The second value.\n     * @return {Number} The result of `a - b`.\n     * @see R.add\n     * @example\n     *\n     *      R.subtract(10, 8); //=> 2\n     *\n     *      var minus5 = R.subtract(R.__, 5);\n     *      minus5(17); //=> 12\n     *\n     *      var complementaryAngle = R.subtract(90);\n     *      complementaryAngle(30); //=> 60\n     *      complementaryAngle(72); //=> 18\n     */\n    var subtract = _curry2(function subtract(a, b) {\n        return a - b;\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropLastWhile\n     * @example\n     *\n     *      var isNotOne = function(x) {\n     *        return !(x === 1);\n     *      };\n     *\n     *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n     */\n    var takeLastWhile = _curry2(function takeLastWhile(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0 && fn(list[idx])) {\n            idx -= 1;\n        }\n        return _slice(list, idx + 1, Infinity);\n    });\n\n    /**\n     * Runs the given function with the supplied object, then returns the object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> *) -> a -> a\n     * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n     * @param {*} x\n     * @return {*} `x`.\n     * @example\n     *\n     *      var sayX = function(x) { console.log('x is ' + x); };\n     *      R.tap(sayX, 100); //=> 100\n     *      //-> 'x is 100'\n     */\n    var tap = _curry2(function tap(fn, x) {\n        fn(x);\n        return x;\n    });\n\n    /**\n     * Determines whether a given string matches a given regular expression.\n     *\n     * @func\n     * @memberOf R\n     * @see R.match\n     * @category String\n     * @sig RegExp -> String -> Boolean\n     * @param {RegExp} pattern\n     * @param {String} str\n     * @return {Boolean}\n     * @example\n     *\n     *      R.test(/^x/, 'xyz'); //=> true\n     *      R.test(/^y/, 'xyz'); //=> false\n     */\n    var test = _curry2(function test(pattern, str) {\n        return _cloneRegExp(pattern).test(str);\n    });\n\n    /**\n     * Calls an input function `n` times, returning an array containing the results of those\n     * function calls.\n     *\n     * `fn` is passed one argument: The current value of `n`, which begins at `0` and is\n     * gradually incremented to `n - 1`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (i -> a) -> i -> [a]\n     * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n     * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n     * @return {Array} An array containing the return values of all calls to `fn`.\n     * @example\n     *\n     *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n     */\n    var times = _curry2(function times(fn, n) {\n        var len = Number(n);\n        var list = new Array(len);\n        var idx = 0;\n        while (idx < len) {\n            list[idx] = fn(idx);\n            idx += 1;\n        }\n        return list;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * Only the object's own properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own properties.\n     * @see R.fromPairs\n     * @example\n     *\n     *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n     */\n    var toPairs = _curry1(function toPairs(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            if (_has(prop, obj)) {\n                pairs[pairs.length] = [\n                    prop,\n                    obj[prop]\n                ];\n            }\n        }\n        return pairs;\n    });\n\n    /**\n     * Converts an object into an array of key, value arrays.\n     * The object's own properties and prototype properties are used.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> [[String,*]]\n     * @param {Object} obj The object to extract from\n     * @return {Array} An array of key, value arrays from the object's own\n     *         and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n     */\n    var toPairsIn = _curry1(function toPairsIn(obj) {\n        var pairs = [];\n        for (var prop in obj) {\n            pairs[pairs.length] = [\n                prop,\n                obj[prop]\n            ];\n        }\n        return pairs;\n    });\n\n    /**\n     * Removes (strips) whitespace from both ends of the string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to trim.\n     * @return {String} Trimmed version of `str`.\n     * @example\n     *\n     *      R.trim('   xyz  '); //=> 'xyz'\n     *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n     */\n    var trim = function () {\n        var ws = '\\t\\n\\x0B\\f\\r \\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\n        var zeroWidth = '\\u200B';\n        var hasProtoTrim = typeof String.prototype.trim === 'function';\n        if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n            return _curry1(function trim(str) {\n                var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n                var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n                return str.replace(beginRx, '').replace(endRx, '');\n            });\n        } else {\n            return _curry1(function trim(str) {\n                return str.trim();\n            });\n        }\n    }();\n\n    /**\n     * Gives a single-word string description of the (native) type of a value, returning such\n     * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n     * Object types any further, reporting them all as 'Object'.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig (* -> {*}) -> String\n     * @param {*} val The value to test\n     * @return {String}\n     * @example\n     *\n     *      R.type({}); //=> \"Object\"\n     *      R.type(1); //=> \"Number\"\n     *      R.type(false); //=> \"Boolean\"\n     *      R.type('s'); //=> \"String\"\n     *      R.type(null); //=> \"Null\"\n     *      R.type([]); //=> \"Array\"\n     *      R.type(/[A-z]/); //=> \"RegExp\"\n     */\n    var type = _curry1(function type(val) {\n        return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n    });\n\n    /**\n     * Takes a function `fn`, which takes a single array argument, and returns\n     * a function which:\n     *\n     *   - takes any number of positional arguments;\n     *   - passes these arguments to `fn` as an array; and\n     *   - returns the result.\n     *\n     * In other words, R.unapply derives a variadic function from a function\n     * which takes an array. R.unapply is the inverse of R.apply.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ([*...] -> a) -> (*... -> a)\n     * @param {Function} fn\n     * @return {Function}\n     * @see R.apply\n     * @example\n     *\n     *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n     */\n    var unapply = _curry1(function unapply(fn) {\n        return function () {\n            return fn(_slice(arguments));\n        };\n    });\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 1\n     * parameter. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> b) -> (a -> b)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 1.\n     * @example\n     *\n     *      var takesTwoArgs = function(a, b) {\n     *        return [a, b];\n     *      };\n     *      takesTwoArgs.length; //=> 2\n     *      takesTwoArgs(1, 2); //=> [1, 2]\n     *\n     *      var takesOneArg = R.unary(takesTwoArgs);\n     *      takesOneArg.length; //=> 1\n     *      // Only 1 argument is passed to the wrapped function\n     *      takesOneArg(1, 2); //=> [1, undefined]\n     */\n    var unary = _curry1(function unary(fn) {\n        return nAry(1, fn);\n    });\n\n    /**\n     * Returns a function of arity `n` from a (manually) curried function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (a -> b) -> (a -> c)\n     * @param {Number} length The arity for the returned function.\n     * @param {Function} fn The function to uncurry.\n     * @return {Function} A new function.\n     * @see R.curry\n     * @example\n     *\n     *      var addFour = function(a) {\n     *        return function(b) {\n     *          return function(c) {\n     *            return function(d) {\n     *              return a + b + c + d;\n     *            };\n     *          };\n     *        };\n     *      };\n     *\n     *      var uncurriedAddFour = R.uncurryN(4, addFour);\n     *      curriedAddFour(1, 2, 3, 4); //=> 10\n     */\n    var uncurryN = _curry2(function uncurryN(depth, fn) {\n        return curryN(depth, function () {\n            var currentDepth = 1;\n            var value = fn;\n            var idx = 0;\n            var endIdx;\n            while (currentDepth <= depth && typeof value === 'function') {\n                endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n                value = value.apply(this, _slice(arguments, idx, endIdx));\n                currentDepth += 1;\n                idx = endIdx;\n            }\n            return value;\n        });\n    });\n\n    /**\n     * Builds a list from a seed value. Accepts an iterator function, which returns either false\n     * to stop iteration or an array of length 2 containing the value to add to the resulting\n     * list and the seed to be used in the next call to the iterator function.\n     *\n     * The iterator function receives one argument: *(seed)*.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> * -> [b]\n     * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n     *        either false to quit iteration or an array of length two to proceed. The element\n     *        at index 0 of this array will be added to the resulting array, and the element\n     *        at index 1 will be passed to the next call to `fn`.\n     * @param {*} seed The seed value.\n     * @return {Array} The final list.\n     * @example\n     *\n     *      var f = function(n) { return n > 50 ? false : [-n, n + 10] };\n     *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n     */\n    var unfold = _curry2(function unfold(fn, seed) {\n        var pair = fn(seed);\n        var result = [];\n        while (pair && pair.length) {\n            result[result.length] = pair[0];\n            pair = fn(pair[1]);\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list, based\n     * upon the value returned by applying the supplied predicate to two list elements. Prefers\n     * the first item if two items compare equal based on the predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      var strEq = function(a, b) { return String(a) === String(b); };\n     *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n     *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n     *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n     *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n     */\n    var uniqWith = _curry2(function uniqWith(pred, list) {\n        var idx = 0, len = list.length;\n        var result = [], item;\n        while (idx < len) {\n            item = list[idx];\n            if (!_containsWith(pred, item, result)) {\n                result[result.length] = item;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Returns a new copy of the array with the element at the\n     * provided index replaced with the given value.\n     * @see R.adjust\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> a -> [a] -> [a]\n     * @param {Number} idx The index to update.\n     * @param {*} x The value to exist at the given index of the returned array.\n     * @param {Array|Arguments} list The source array-like object to be updated.\n     * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n     * @example\n     *\n     *      R.update(1, 11, [0, 1, 2]);     //=> [0, 11, 2]\n     *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\n     */\n    var update = _curry3(function update(idx, x, list) {\n        return adjust(always(x), idx, list);\n    });\n\n    /**\n     * Returns a list of all the enumerable own properties of the supplied object.\n     * Note that the order of the output array is not guaranteed across\n     * different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own properties.\n     * @example\n     *\n     *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n     */\n    var values = _curry1(function values(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var vals = [];\n        var idx = 0;\n        while (idx < len) {\n            vals[idx] = obj[props[idx]];\n            idx += 1;\n        }\n        return vals;\n    });\n\n    /**\n     * Returns a list of all the properties, including prototype properties,\n     * of the supplied object.\n     * Note that the order of the output array is not guaranteed to be\n     * consistent across different JS platforms.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {k: v} -> [v]\n     * @param {Object} obj The object to extract values from\n     * @return {Array} An array of the values of the object's own and prototype properties.\n     * @example\n     *\n     *      var F = function() { this.x = 'X'; };\n     *      F.prototype.y = 'Y';\n     *      var f = new F();\n     *      R.valuesIn(f); //=> ['X', 'Y']\n     */\n    var valuesIn = _curry1(function valuesIn(obj) {\n        var prop, vs = [];\n        for (prop in obj) {\n            vs[vs.length] = obj[prop];\n        }\n        return vs;\n    });\n\n    /**\n     * Returns a \"view\" of the given data structure, determined by the given lens.\n     * The lens's focus determines which portion of the data structure is visible.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Lens s a -> s -> a\n     * @param {Lens} lens\n     * @param {*} x\n     * @return {*}\n     * @see R.prop, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});  //=> 1\n     *      R.view(xLens, {x: 4, y: 2});  //=> 4\n     */\n    var view = function () {\n        var Const = function (x) {\n            return {\n                value: x,\n                map: function () {\n                    return this;\n                }\n            };\n        };\n        return _curry2(function view(lens, x) {\n            return lens(Const)(x).value;\n        });\n    }();\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec. Each of the spec's own properties must be a predicate function.\n     * Each predicate is applied to the value of the corresponding property of\n     * the test object. `where` returns true if all the predicates return true,\n     * false otherwise.\n     *\n     * `where` is well suited to declaratively expressing constraints for other\n     * functions such as `filter` and `find`.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.where({\n     *        a: R.equals('foo'),\n     *        b: R.complement(R.equals('bar')),\n     *        x: R.gt(_, 10),\n     *        y: R.lt(_, 20)\n     *      });\n     *\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n     *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n     *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n     */\n    var where = _curry2(function where(spec, testObj) {\n        for (var prop in spec) {\n            if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n                return false;\n            }\n        }\n        return true;\n    });\n\n    /**\n     * Wrap a function inside another to allow you to make adjustments to the parameters, or do\n     * other processing either before the internal function is called or with its results.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)\n     * @param {Function} fn The function to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var greet = function(name) {return 'Hello ' + name;};\n     *\n     *      var shoutedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name).toUpperCase();\n     *      });\n     *      shoutedGreet(\"Kathy\"); //=> \"HELLO KATHY\"\n     *\n     *      var shortenedGreet = R.wrap(greet, function(gr, name) {\n     *        return gr(name.substring(0, 3));\n     *      });\n     *      shortenedGreet(\"Robert\"); //=> \"Hello Rob\"\n     */\n    var wrap = _curry2(function wrap(fn, wrapper) {\n        return curryN(fn.length, function () {\n            return wrapper.apply(this, _concat([fn], arguments));\n        });\n    });\n\n    /**\n     * Creates a new list out of the two supplied by creating each possible\n     * pair from the lists.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The list made by combining each possible pair from\n     *         `as` and `bs` into pairs (`[a, b]`).\n     * @example\n     *\n     *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n     */\n    // = xprodWith(prepend); (takes about 3 times as long...)\n    var xprod = _curry2(function xprod(a, b) {\n        // = xprodWith(prepend); (takes about 3 times as long...)\n        var idx = 0;\n        var ilen = a.length;\n        var j;\n        var jlen = b.length;\n        var result = [];\n        while (idx < ilen) {\n            j = 0;\n            while (j < jlen) {\n                result[result.length] = [\n                    a[idx],\n                    b[j]\n                ];\n                j += 1;\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by pairing up\n     * equally-positioned items from both lists.  The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b] -> [[a,b]]\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n     * @example\n     *\n     *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n     */\n    var zip = _curry2(function zip(a, b) {\n        var rv = [];\n        var idx = 0;\n        var len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = [\n                a[idx],\n                b[idx]\n            ];\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * Creates a new object out of a list of keys and a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [String] -> [*] -> {String: *}\n     * @param {Array} keys The array that will be properties on the output object.\n     * @param {Array} values The list of values on the output object.\n     * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n     * @example\n     *\n     *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n     */\n    var zipObj = _curry2(function zipObj(keys, values) {\n        var idx = 0, len = keys.length, out = {};\n        while (idx < len) {\n            out[keys[idx]] = values[idx];\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Creates a new list out of the two supplied by applying the function to\n     * each equally-positioned pair in the lists. The returned list is\n     * truncated to the length of the shorter of the two input lists.\n     *\n     * @function\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> c) -> [a] -> [b] -> [c]\n     * @param {Function} fn The function used to combine the two elements into one value.\n     * @param {Array} list1 The first array to consider.\n     * @param {Array} list2 The second array to consider.\n     * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n     *         using `fn`.\n     * @example\n     *\n     *      var f = function(x, y) {\n     *        // ...\n     *      };\n     *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n     *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n     */\n    var zipWith = _curry3(function zipWith(fn, a, b) {\n        var rv = [], idx = 0, len = Math.min(a.length, b.length);\n        while (idx < len) {\n            rv[idx] = fn(a[idx], b[idx]);\n            idx += 1;\n        }\n        return rv;\n    });\n\n    /**\n     * A function that always returns `false`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> false\n     * @return {Boolean} false\n     * @see R.always, R.T\n     * @example\n     *\n     *      R.F(); //=> false\n     */\n    var F = always(false);\n\n    /**\n     * A function that always returns `true`. Any passed in parameters are ignored.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig * -> true\n     * @return {Boolean} `true`.\n     * @see R.always, R.F\n     * @example\n     *\n     *      R.T(); //=> true\n     */\n    var T = always(true);\n\n    /**\n     * Similar to hasMethod, this checks whether a function has a [methodname]\n     * function. If it isn't an array it will execute that function otherwise it will\n     * default to the ramda implementation.\n     *\n     * @private\n     * @param {Function} fn ramda implemtation\n     * @param {String} methodname property to check for a custom implementation\n     * @return {Object} Whatever the return value of the method is.\n     */\n    var _checkForMethod = function _checkForMethod(methodname, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n        };\n    };\n\n    /**\n     * Copies an object.\n     *\n     * @private\n     * @param {*} value The value to be copied\n     * @param {Array} refFrom Array containing the source references\n     * @param {Array} refTo Array containing the copied source references\n     * @return {*} The copied value.\n     */\n    var _clone = function _clone(value, refFrom, refTo) {\n        var copy = function copy(copiedValue) {\n            var len = refFrom.length;\n            var idx = 0;\n            while (idx < len) {\n                if (value === refFrom[idx]) {\n                    return refTo[idx];\n                }\n                idx += 1;\n            }\n            refFrom[idx + 1] = value;\n            refTo[idx + 1] = copiedValue;\n            for (var key in value) {\n                copiedValue[key] = _clone(value[key], refFrom, refTo);\n            }\n            return copiedValue;\n        };\n        switch (type(value)) {\n        case 'Object':\n            return copy({});\n        case 'Array':\n            return copy([]);\n        case 'Date':\n            return new Date(value);\n        case 'RegExp':\n            return _cloneRegExp(value);\n        default:\n            return value;\n        }\n    };\n\n    var _createPartialApplicator = function _createPartialApplicator(concat) {\n        return function (fn) {\n            var args = _slice(arguments, 1);\n            return _arity(Math.max(0, fn.length - args.length), function () {\n                return fn.apply(this, concat(args, arguments));\n            });\n        };\n    };\n\n    /**\n     * Returns a function that dispatches with different strategies based on the\n     * object in list position (last argument). If it is an array, executes [fn].\n     * Otherwise, if it has a  function with [methodname], it will execute that\n     * function (functor case). Otherwise, if it is a transformer, uses transducer\n     * [xf] to return a new transformer (transducer case). Otherwise, it will\n     * default to executing [fn].\n     *\n     * @private\n     * @param {String} methodname property to check for a custom implementation\n     * @param {Function} xf transducer to initialize if object is transformer\n     * @param {Function} fn default ramda implementation\n     * @return {Function} A function that dispatches on object in list position\n     */\n    var _dispatchable = function _dispatchable(methodname, xf, fn) {\n        return function () {\n            var length = arguments.length;\n            if (length === 0) {\n                return fn();\n            }\n            var obj = arguments[length - 1];\n            if (!_isArray(obj)) {\n                var args = _slice(arguments, 0, length - 1);\n                if (typeof obj[methodname] === 'function') {\n                    return obj[methodname].apply(obj, args);\n                }\n                if (_isTransformer(obj)) {\n                    var transducer = xf.apply(null, args);\n                    return transducer(obj);\n                }\n            }\n            return fn.apply(this, arguments);\n        };\n    };\n\n    // The algorithm used to handle cyclic structures is\n    // inspired by underscore's isEqual\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    var _equals = function _equals(a, b, stackA, stackB) {\n        var typeA = type(a);\n        if (typeA !== type(b)) {\n            return false;\n        }\n        if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n            return typeof a === 'object' ? typeof b === 'object' && identical(a.valueOf(), b.valueOf()) : identical(a, b);\n        }\n        if (identical(a, b)) {\n            return true;\n        }\n        if (typeA === 'RegExp') {\n            // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n            return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode;\n        }\n        if (Object(a) === a) {\n            if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n                return false;\n            }\n            var keysA = keys(a);\n            if (keysA.length !== keys(b).length) {\n                return false;\n            }\n            var idx = stackA.length - 1;\n            while (idx >= 0) {\n                if (stackA[idx] === a) {\n                    return stackB[idx] === b;\n                }\n                idx -= 1;\n            }\n            stackA[stackA.length] = a;\n            stackB[stackB.length] = b;\n            idx = keysA.length - 1;\n            while (idx >= 0) {\n                var key = keysA[idx];\n                if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n                    return false;\n                }\n                idx -= 1;\n            }\n            stackA.pop();\n            stackB.pop();\n            return true;\n        }\n        return false;\n    };\n\n    /**\n     * Private function that determines whether or not a provided object has a given method.\n     * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n     * dispatching Ramda methods to non-Array objects.\n     *\n     * @private\n     * @param {String} methodName The name of the method to check for.\n     * @param {Object} obj The object to test.\n     * @return {Boolean} `true` has a given method, `false` otherwise.\n     * @example\n     *\n     *      var person = { name: 'John' };\n     *      person.shout = function() { alert(this.name); };\n     *\n     *      _hasMethod('shout', person); //=> true\n     *      _hasMethod('foo', person); //=> false\n     */\n    var _hasMethod = function _hasMethod(methodName, obj) {\n        return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n    };\n\n    /**\n     * `_makeFlat` is a helper function that returns a one-level or fully recursive function\n     * based on the flag passed in.\n     *\n     * @private\n     */\n    var _makeFlat = function _makeFlat(recursive) {\n        return function flatt(list) {\n            var value, result = [], idx = 0, j, ilen = list.length, jlen;\n            while (idx < ilen) {\n                if (isArrayLike(list[idx])) {\n                    value = recursive ? flatt(list[idx]) : list[idx];\n                    j = 0;\n                    jlen = value.length;\n                    while (j < jlen) {\n                        result[result.length] = value[j];\n                        j += 1;\n                    }\n                } else {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n            return result;\n        };\n    };\n\n    var _reduce = function () {\n        function _arrayReduce(xf, acc, list) {\n            var idx = 0, len = list.length;\n            while (idx < len) {\n                acc = xf['@@transducer/step'](acc, list[idx]);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                idx += 1;\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _iterableReduce(xf, acc, iter) {\n            var step = iter.next();\n            while (!step.done) {\n                acc = xf['@@transducer/step'](acc, step.value);\n                if (acc && acc['@@transducer/reduced']) {\n                    acc = acc['@@transducer/value'];\n                    break;\n                }\n                step = iter.next();\n            }\n            return xf['@@transducer/result'](acc);\n        }\n        function _methodReduce(xf, acc, obj) {\n            return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n        }\n        var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n        return function _reduce(fn, acc, list) {\n            if (typeof fn === 'function') {\n                fn = _xwrap(fn);\n            }\n            if (isArrayLike(list)) {\n                return _arrayReduce(fn, acc, list);\n            }\n            if (typeof list.reduce === 'function') {\n                return _methodReduce(fn, acc, list);\n            }\n            if (list[symIterator] != null) {\n                return _iterableReduce(fn, acc, list[symIterator]());\n            }\n            if (typeof list.next === 'function') {\n                return _iterableReduce(fn, acc, list);\n            }\n            throw new TypeError('reduce: list must be array or iterable');\n        };\n    }();\n\n    var _stepCat = function () {\n        var _stepCatArray = {\n            '@@transducer/init': Array,\n            '@@transducer/step': function (xs, x) {\n                return _concat(xs, [x]);\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatString = {\n            '@@transducer/init': String,\n            '@@transducer/step': function (a, b) {\n                return a + b;\n            },\n            '@@transducer/result': _identity\n        };\n        var _stepCatObject = {\n            '@@transducer/init': Object,\n            '@@transducer/step': function (result, input) {\n                return merge(result, isArrayLike(input) ? createMapEntry(input[0], input[1]) : input);\n            },\n            '@@transducer/result': _identity\n        };\n        return function _stepCat(obj) {\n            if (_isTransformer(obj)) {\n                return obj;\n            }\n            if (isArrayLike(obj)) {\n                return _stepCatArray;\n            }\n            if (typeof obj === 'string') {\n                return _stepCatString;\n            }\n            if (typeof obj === 'object') {\n                return _stepCatObject;\n            }\n            throw new Error('Cannot create transformer for ' + obj);\n        };\n    }();\n\n    var _xall = function () {\n        function XAll(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.all = true;\n        }\n        XAll.prototype['@@transducer/init'] = _xfBase.init;\n        XAll.prototype['@@transducer/result'] = function (result) {\n            if (this.all) {\n                result = this.xf['@@transducer/step'](result, true);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAll.prototype['@@transducer/step'] = function (result, input) {\n            if (!this.f(input)) {\n                this.all = false;\n                result = _reduced(this.xf['@@transducer/step'](result, false));\n            }\n            return result;\n        };\n        return _curry2(function _xall(f, xf) {\n            return new XAll(f, xf);\n        });\n    }();\n\n    var _xany = function () {\n        function XAny(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.any = false;\n        }\n        XAny.prototype['@@transducer/init'] = _xfBase.init;\n        XAny.prototype['@@transducer/result'] = function (result) {\n            if (!this.any) {\n                result = this.xf['@@transducer/step'](result, false);\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XAny.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f(input)) {\n                this.any = true;\n                result = _reduced(this.xf['@@transducer/step'](result, true));\n            }\n            return result;\n        };\n        return _curry2(function _xany(f, xf) {\n            return new XAny(f, xf);\n        });\n    }();\n\n    var _xdrop = function () {\n        function XDrop(n, xf) {\n            this.xf = xf;\n            this.n = n;\n        }\n        XDrop.prototype['@@transducer/init'] = _xfBase.init;\n        XDrop.prototype['@@transducer/result'] = _xfBase.result;\n        XDrop.prototype['@@transducer/step'] = function (result, input) {\n            if (this.n > 0) {\n                this.n -= 1;\n                return result;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdrop(n, xf) {\n            return new XDrop(n, xf);\n        });\n    }();\n\n    var _xdropWhile = function () {\n        function XDropWhile(f, xf) {\n            this.xf = xf;\n            this.f = f;\n        }\n        XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n        XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n        XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n            if (this.f) {\n                if (this.f(input)) {\n                    return result;\n                }\n                this.f = null;\n            }\n            return this.xf['@@transducer/step'](result, input);\n        };\n        return _curry2(function _xdropWhile(f, xf) {\n            return new XDropWhile(f, xf);\n        });\n    }();\n\n    var _xgroupBy = function () {\n        function XGroupBy(f, xf) {\n            this.xf = xf;\n            this.f = f;\n            this.inputs = {};\n        }\n        XGroupBy.prototype['@@transducer/init'] = _xfBase.init;\n        XGroupBy.prototype['@@transducer/result'] = function (result) {\n            var key;\n            for (key in this.inputs) {\n                if (_has(key, this.inputs)) {\n                    result = this.xf['@@transducer/step'](result, this.inputs[key]);\n                    if (result['@@transducer/reduced']) {\n                        result = result['@@transducer/value'];\n                        break;\n                    }\n                }\n            }\n            return this.xf['@@transducer/result'](result);\n        };\n        XGroupBy.prototype['@@transducer/step'] = function (result, input) {\n            var key = this.f(input);\n            this.inputs[key] = this.inputs[key] || [\n                key,\n                []\n            ];\n            this.inputs[key][1] = append(input, this.inputs[key][1]);\n            return result;\n        };\n        return _curry2(function _xgroupBy(f, xf) {\n            return new XGroupBy(f, xf);\n        });\n    }();\n\n    /**\n     * Creates a new list iteration function from an existing one by adding two new parameters\n     * to its callback function: the current index, and the entire list.\n     *\n     * This would turn, for instance, Ramda's simple `map` function into one that more closely\n     * resembles `Array.prototype.map`.  Note that this will only work for functions in which\n     * the iteration callback function is the first parameter, and where the list is the last\n     * parameter.  (This latter might be unimportant if the list parameter is not used.)\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @category List\n     * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n     * @param {Function} fn A list iteration function that does not pass index or list to its callback\n     * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n     * @example\n     *\n     *      var mapIndexed = R.addIndex(R.map);\n     *      mapIndexed(function(val, idx) {return idx + '-' + val;}, ['f', 'o', 'o', 'b', 'a', 'r']);\n     *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n     */\n    var addIndex = _curry1(function addIndex(fn) {\n        return curryN(fn.length, function () {\n            var idx = 0;\n            var origFn = arguments[0];\n            var list = arguments[arguments.length - 1];\n            var args = _slice(arguments);\n            args[0] = function () {\n                var result = origFn.apply(this, _concat(arguments, [\n                    idx,\n                    list\n                ]));\n                idx += 1;\n                return result;\n            };\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Returns `true` if all elements of the list match the predicate, `false` if there are any\n     * that don't.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n     *         otherwise.\n     * @see R.any, R.none\n     * @example\n     *\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      var lessThan3 = R.flip(R.lt)(3);\n     *      R.all(lessThan2)([1, 2]); //=> false\n     *      R.all(lessThan3)([1, 2]); //=> true\n     */\n    var all = _curry2(_dispatchable('all', _xall, function all(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (!fn(list[idx])) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    }));\n\n    /**\n     * A function that returns the first argument if it's falsy otherwise the second\n     * argument. Note that this is NOT short-circuited, meaning that if expressions\n     * are passed they are both evaluated.\n     *\n     * Dispatches to the `and` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first argument if falsy otherwise the second argument.\n     * @see R.both\n     * @example\n     *\n     *      R.and(false, true); //=> false\n     *      R.and(0, []); //=> 0\n     *      R.and(null, ''); => null\n     */\n    var and = _curry2(function and(a, b) {\n        return _hasMethod('and', a) ? a.and(b) : a && b;\n    });\n\n    /**\n     * Returns `true` if at least one of elements of the list match the predicate, `false`\n     * otherwise.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n     *         otherwise.\n     * @see R.all, R.none\n     * @example\n     *\n     *      var lessThan0 = R.flip(R.lt)(0);\n     *      var lessThan2 = R.flip(R.lt)(2);\n     *      R.any(lessThan0)([1, 2]); //=> false\n     *      R.any(lessThan2)([1, 2]); //=> true\n     */\n    var any = _curry2(_dispatchable('any', _xany, function any(fn, list) {\n        var idx = 0;\n        while (idx < list.length) {\n            if (fn(list[idx])) {\n                return true;\n            }\n            idx += 1;\n        }\n        return false;\n    }));\n\n    /**\n     * Wraps a function of any arity (including nullary) in a function that accepts exactly 2\n     * parameters. Any extraneous parameters will not be passed to the supplied function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> c) -> (a, b -> c)\n     * @param {Function} fn The function to wrap.\n     * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n     *         arity 2.\n     * @example\n     *\n     *      var takesThreeArgs = function(a, b, c) {\n     *        return [a, b, c];\n     *      };\n     *      takesThreeArgs.length; //=> 3\n     *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      var takesTwoArgs = R.binary(takesThreeArgs);\n     *      takesTwoArgs.length; //=> 2\n     *      // Only 2 arguments are passed to the wrapped function\n     *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n     */\n    var binary = _curry1(function binary(fn) {\n        return nAry(2, fn);\n    });\n\n    /**\n     * Creates a deep copy of the value which may contain (nested) `Array`s and\n     * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n     * not copied, but assigned by their reference.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> {*}\n     * @param {*} value The object or array to clone\n     * @return {*} A new object or array.\n     * @example\n     *\n     *      var objects = [{}, {}, {}];\n     *      var objectsClone = R.clone(objects);\n     *      objects[0] === objectsClone[0]; //=> false\n     */\n    var clone = _curry1(function clone(value) {\n        return _clone(value, [], []);\n    });\n\n    /**\n     * Returns a new list consisting of the elements of the first list followed by the elements\n     * of the second.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list to merge.\n     * @param {Array} list2 The second set to merge.\n     * @return {Array} A new array consisting of the contents of `list1` followed by the\n     *         contents of `list2`. If, instead of an Array for `list1`, you pass an\n     *         object with a `concat` method on it, `concat` will call `list1.concat`\n     *         and pass it the value of `list2`.\n     *\n     * @example\n     *\n     *      R.concat([], []); //=> []\n     *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n     *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n     */\n    var concat = _curry2(function concat(set1, set2) {\n        if (_isArray(set2)) {\n            return _concat(set1, set2);\n        } else if (_hasMethod('concat', set1)) {\n            return set1.concat(set2);\n        } else {\n            throw new TypeError('can\\'t concat ' + typeof set1);\n        }\n    });\n\n    /**\n     * Returns a curried equivalent of the provided function. The curried\n     * function has two unusual capabilities. First, its arguments needn't\n     * be provided one at a time. If `f` is a ternary function and `g` is\n     * `R.curry(f)`, the following are equivalent:\n     *\n     *   - `g(1)(2)(3)`\n     *   - `g(1)(2, 3)`\n     *   - `g(1, 2)(3)`\n     *   - `g(1, 2, 3)`\n     *\n     * Secondly, the special placeholder value `R.__` may be used to specify\n     * \"gaps\", allowing partial application of any combination of arguments,\n     * regardless of their positions. If `g` is as above and `_` is `R.__`,\n     * the following are equivalent:\n     *\n     *   - `g(1, 2, 3)`\n     *   - `g(_, 2, 3)(1)`\n     *   - `g(_, _, 3)(1)(2)`\n     *   - `g(_, _, 3)(1, 2)`\n     *   - `g(_, 2)(1)(3)`\n     *   - `g(_, 2)(1, 3)`\n     *   - `g(_, 2)(_, 3)(1)`\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> a) -> (* -> a)\n     * @param {Function} fn The function to curry.\n     * @return {Function} A new, curried function.\n     * @see R.curryN\n     * @example\n     *\n     *      var addFourNumbers = function(a, b, c, d) {\n     *        return a + b + c + d;\n     *      };\n     *\n     *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n     *      var f = curriedAddFourNumbers(1, 2);\n     *      var g = f(3);\n     *      g(4); //=> 10\n     */\n    var curry = _curry1(function curry(fn) {\n        return curryN(fn.length, fn);\n    });\n\n    /**\n     * Returns a new list containing the last `n` elements of a given list, passing each value\n     * to the supplied predicate function, skipping elements while the predicate function returns\n     * `true`. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.takeWhile\n     * @example\n     *\n     *      var lteTwo = function(x) {\n     *        return x <= 2;\n     *      };\n     *\n     *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n     */\n    var dropWhile = _curry2(_dispatchable('dropWhile', _xdropWhile, function dropWhile(pred, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && pred(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, idx);\n    }));\n\n    /**\n     * Returns `true` if its arguments are equivalent, `false` otherwise.\n     * Dispatches to an `equals` method if present. Handles cyclical data\n     * structures.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig a -> b -> Boolean\n     * @param {*} a\n     * @param {*} b\n     * @return {Boolean}\n     * @example\n     *\n     *      R.equals(1, 1); //=> true\n     *      R.equals(1, '1'); //=> false\n     *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n     *\n     *      var a = {}; a.v = a;\n     *      var b = {}; b.v = b;\n     *      R.equals(a, b); //=> true\n     */\n    var equals = _curry2(function equals(a, b) {\n        return _hasMethod('equals', a) ? a.equals(b) : _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n    });\n\n    /**\n     * Returns a new list containing only those items that match a given predicate function.\n     * The predicate function is passed one argument: *(value)*.\n     *\n     * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n     * `Array.prototype.filter` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.reject\n     * @example\n     *\n     *      var isEven = function(n) {\n     *        return n % 2 === 0;\n     *      };\n     *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var filter = _curry2(_dispatchable('filter', _xfilter, _filter));\n\n    /**\n     * Returns the first element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     *        desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n     *      R.find(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var find = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx += 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the first element of the list which matches the predicate, or `-1`\n     * if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n     *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n     *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findIndex = _curry2(_dispatchable('findIndex', _xfindIndex, function findIndex(fn, list) {\n        var idx = 0;\n        var len = list.length;\n        while (idx < len) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns the last element of the list which matches the predicate, or `undefined` if no\n     * element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> a | undefined\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Object} The element found, or `undefined`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n     *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n     */\n    var findLast = _curry2(_dispatchable('findLast', _xfindLast, function findLast(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return list[idx];\n            }\n            idx -= 1;\n        }\n    }));\n\n    /**\n     * Returns the index of the last element of the list which matches the predicate, or\n     * `-1` if no element matches.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Number\n     * @param {Function} fn The predicate function used to determine if the element is the\n     * desired one.\n     * @param {Array} list The array to consider.\n     * @return {Number} The index of the element found, or `-1`.\n     * @example\n     *\n     *      var xs = [{a: 1, b: 0}, {a:1, b: 1}];\n     *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n     *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n     */\n    var findLastIndex = _curry2(_dispatchable('findLastIndex', _xfindLastIndex, function findLastIndex(fn, list) {\n        var idx = list.length - 1;\n        while (idx >= 0) {\n            if (fn(list[idx])) {\n                return idx;\n            }\n            idx -= 1;\n        }\n        return -1;\n    }));\n\n    /**\n     * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\n     * them in a new array, depth-first.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.unnest\n     * @example\n     *\n     *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n     *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n     */\n    var flatten = _curry1(_makeFlat(true));\n\n    /**\n     * Returns a new function much like the supplied one, except that the first two arguments'\n     * order is reversed.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)\n     * @param {Function} fn The function to invoke with its first two parameters reversed.\n     * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n     * @example\n     *\n     *      var mergeThree = function(a, b, c) {\n     *        return ([]).concat(a, b, c);\n     *      };\n     *\n     *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n     *\n     *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n     */\n    var flip = _curry1(function flip(fn) {\n        return curry(function (a, b) {\n            var args = _slice(arguments);\n            args[0] = b;\n            args[1] = a;\n            return fn.apply(this, args);\n        });\n    });\n\n    /**\n     * Iterate over an input `list`, calling a provided function `fn` for each element in the\n     * list.\n     *\n     * `fn` receives one argument: *(value)*.\n     *\n     * Note: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.forEach` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n     *\n     * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\n     * array. In some libraries this function is named `each`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> *) -> [a] -> [a]\n     * @param {Function} fn The function to invoke. Receives one argument, `value`.\n     * @param {Array} list The list to iterate over.\n     * @return {Array} The original list.\n     * @example\n     *\n     *      var printXPlusFive = function(x) { console.log(x + 5); };\n     *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n     *      //-> 6\n     *      //-> 7\n     *      //-> 8\n     */\n    var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            fn(list[idx]);\n            idx += 1;\n        }\n        return list;\n    }));\n\n    /**\n     * Returns a list of function names of object's own functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties that map to functions.\n     * @example\n     *\n     *      R.functions(R); // returns list of ramda's own function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functions(new F()); //=> [\"x\"]\n     */\n    var functions = _curry1(_functionsWith(keys));\n\n    /**\n     * Returns a list of function names of object's own and prototype functions\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {*} -> [String]\n     * @param {Object} obj The objects with functions in it\n     * @return {Array} A list of the object's own properties and prototype\n     *         properties that map to functions.\n     * @example\n     *\n     *      R.functionsIn(R); // returns list of ramda's own and prototype function names\n     *\n     *      var F = function() { this.x = function(){}; this.y = 1; }\n     *      F.prototype.z = function() {};\n     *      F.prototype.a = 100;\n     *      R.functionsIn(new F()); //=> [\"x\", \"z\"]\n     */\n    var functionsIn = _curry1(_functionsWith(keysIn));\n\n    /**\n     * Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\n     * on each element, and grouping the results according to values returned.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> String) -> [a] -> {String: [a]}\n     * @param {Function} fn Function :: a -> String\n     * @param {Array} list The array to group\n     * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n     *         that produced that key when passed to `fn`.\n     * @example\n     *\n     *      var byGrade = R.groupBy(function(student) {\n     *        var score = student.score;\n     *        return score < 65 ? 'F' :\n     *               score < 70 ? 'D' :\n     *               score < 80 ? 'C' :\n     *               score < 90 ? 'B' : 'A';\n     *      });\n     *      var students = [{name: 'Abby', score: 84},\n     *                      {name: 'Eddy', score: 58},\n     *                      // ...\n     *                      {name: 'Jack', score: 69}];\n     *      byGrade(students);\n     *      // {\n     *      //   'A': [{name: 'Dianne', score: 99}],\n     *      //   'B': [{name: 'Abby', score: 84}]\n     *      //   // ...,\n     *      //   'F': [{name: 'Eddy', score: 58}]\n     *      // }\n     */\n    var groupBy = _curry2(_dispatchable('groupBy', _xgroupBy, function groupBy(fn, list) {\n        return _reduce(function (acc, elt) {\n            var key = fn(elt);\n            acc[key] = append(elt, acc[key] || (acc[key] = []));\n            return acc;\n        }, {}, list);\n    }));\n\n    /**\n     * Returns the first element of the given list or string. In some libraries\n     * this function is named `first`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.tail, R.init, R.last\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n     *      R.head([]); //=> undefined\n     *\n     *      R.head('abc'); //=> 'a'\n     *      R.head(''); //=> ''\n     */\n    var head = nth(0);\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those\n     * elements common to both lists.  Duplication is determined according\n     * to the value returned by applying the supplied predicate to two list\n     * elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate function that determines whether\n     *        the two supplied elements are equal.\n     * @param {Array} list1 One list of items to compare\n     * @param {Array} list2 A second list of items to compare\n     * @see R.intersection\n     * @return {Array} A new list containing those elements common to both lists.\n     * @example\n     *\n     *      var buffaloSpringfield = [\n     *        {id: 824, name: 'Richie Furay'},\n     *        {id: 956, name: 'Dewey Martin'},\n     *        {id: 313, name: 'Bruce Palmer'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *      var csny = [\n     *        {id: 204, name: 'David Crosby'},\n     *        {id: 456, name: 'Stephen Stills'},\n     *        {id: 539, name: 'Graham Nash'},\n     *        {id: 177, name: 'Neil Young'}\n     *      ];\n     *\n     *      var sameId = function(o1, o2) {return o1.id === o2.id;};\n     *\n     *      R.intersectionWith(sameId, buffaloSpringfield, csny);\n     *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n     */\n    var intersectionWith = _curry3(function intersectionWith(pred, list1, list2) {\n        var results = [], idx = 0;\n        while (idx < list1.length) {\n            if (_containsWith(pred, list1[idx], list2)) {\n                results[results.length] = list1[idx];\n            }\n            idx += 1;\n        }\n        return uniqWith(pred, results);\n    });\n\n    /**\n     * Creates a new list with the separator interposed between elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> [a]\n     * @param {*} separator The element to add to the list.\n     * @param {Array} list The list to be interposed.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n     */\n    var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n        var out = [];\n        var idx = 0;\n        var length = list.length;\n        while (idx < length) {\n            if (idx === length - 1) {\n                out.push(list[idx]);\n            } else {\n                out.push(list[idx], separator);\n            }\n            idx += 1;\n        }\n        return out;\n    }));\n\n    /**\n     * Transforms the items of the list with the transducer and appends the transformed items to\n     * the accumulator using an appropriate iterator function based on the accumulator type.\n     *\n     * The accumulator can be an array, string, object or a transformer. Iterated items will\n     * be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\n     * arrays will be merged as key, value pairs.\n     *\n     * The accumulator can also be a transformer object that provides a 2-arity reducing iterator\n     * function, step, 0-arity initial value function, init, and 1-arity result extraction function\n     * result. The step function is used as the iterator function in reduce. The result function is\n     * used to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function is used to provide the initial accumulator.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> (b -> b) -> [c] -> a\n     * @param {*} acc The initial accumulator value.\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.into([], transducer, numbers); //=> [2, 3]\n     *\n     *      var intoArray = R.into([]);\n     *      intoArray(transducer, numbers); //=> [2, 3]\n     */\n    var into = _curry3(function into(acc, xf, list) {\n        return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), acc, list);\n    });\n\n    /**\n     * Same as R.invertObj, however this accounts for objects\n     * with duplicate values by putting the values into an\n     * array.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: [ s, ... ]}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object with keys\n     * in an array.\n     * @example\n     *\n     *      var raceResultsByFirstName = {\n     *        first: 'alice',\n     *        second: 'jake',\n     *        third: 'alice',\n     *      };\n     *      R.invert(raceResultsByFirstName);\n     *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n     */\n    var invert = _curry1(function invert(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            var val = obj[key];\n            var list = _has(val, out) ? out[val] : out[val] = [];\n            list[list.length] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new object with the keys of the given object\n     * as values, and the values of the given object as keys.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {s: x} -> {x: s}\n     * @param {Object} obj The object or array to invert\n     * @return {Object} out A new object\n     * @example\n     *\n     *      var raceResults = {\n     *        first: 'alice',\n     *        second: 'jake'\n     *      };\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': 'first', 'jake':'second' }\n     *\n     *      // Alternatively:\n     *      var raceResults = ['alice', 'jake'];\n     *      R.invertObj(raceResults);\n     *      //=> { 'alice': '0', 'jake':'1' }\n     */\n    var invertObj = _curry1(function invertObj(obj) {\n        var props = keys(obj);\n        var len = props.length;\n        var idx = 0;\n        var out = {};\n        while (idx < len) {\n            var key = props[idx];\n            out[obj[key]] = key;\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.init, R.head, R.tail\n     * @sig [a] -> a | Undefined\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n     *      R.last([]); //=> undefined\n     *\n     *      R.last('abc'); //=> 'c'\n     *      R.last(''); //=> ''\n     */\n    var last = nth(-1);\n\n    /**\n     * Returns the position of the last occurrence of an item in\n     * an array, or -1 if the item is not included in the array.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.indexOf\n     * @example\n     *\n     *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n     *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n     */\n    var lastIndexOf = _curry2(function lastIndexOf(target, xs) {\n        if (_hasMethod('lastIndexOf', xs)) {\n            return xs.lastIndexOf(target);\n        } else {\n            var idx = xs.length - 1;\n            while (idx >= 0) {\n                if (equals(xs[idx], target)) {\n                    return idx;\n                }\n                idx -= 1;\n            }\n            return -1;\n        }\n    });\n\n    /**\n     * Returns a new list, constructed by applying the supplied function to every element of the\n     * supplied list.\n     *\n     * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n     * native `Array.prototype.map` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [b]\n     * @param {Function} fn The function to be called on every element of the input `list`.\n     * @param {Array} list The list to be iterated over.\n     * @return {Array} The new list.\n     * @example\n     *\n     *      var double = function(x) {\n     *        return x * 2;\n     *      };\n     *\n     *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n     */\n    var map = _curry2(_dispatchable('map', _xmap, _map));\n\n    /**\n     * Map, but for objects. Creates an object with the same keys as `obj` and values\n     * generated by running each property of `obj` through `fn`. `fn` is passed one argument:\n     * *(value)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     * become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var double = function(num) {\n     *        return num * 2;\n     *      };\n     *\n     *      R.mapObj(double, values); //=> { x: 2, y: 4, z: 6 }\n     */\n    var mapObj = _curry2(function mapObj(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key]);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Like `mapObj`, but but passes additional arguments to the predicate function. The\n     * predicate function is passed three arguments: *(value, key, obj)*.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig (v, k, {k: v} -> v) -> {k: v} -> {k: v}\n     * @param {Function} fn A function called for each property in `obj`. Its return value will\n     *        become a new property on the return object.\n     * @param {Object} obj The object to iterate over.\n     * @return {Object} A new object with the same keys as `obj` and values that are the result\n     *         of running each property through `fn`.\n     * @example\n     *\n     *      var values = { x: 1, y: 2, z: 3 };\n     *      var prependKeyAndDouble = function(num, key, obj) {\n     *        return key + (num * 2);\n     *      };\n     *\n     *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n     */\n    var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) {\n        return _reduce(function (acc, key) {\n            acc[key] = fn(obj[key], key, obj);\n            return acc;\n        }, {}, keys(obj));\n    });\n\n    /**\n     * Returns `true` if no elements of the list match the predicate,\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> Boolean\n     * @param {Function} fn The predicate function.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n     * @see R.all, R.any\n     * @example\n     *\n     *      R.none(R.isNaN, [1, 2, 3]); //=> true\n     *      R.none(R.isNaN, [1, 2, 3, NaN]); //=> false\n     */\n    var none = _curry2(_complement(_dispatchable('any', _xany, any)));\n\n    /**\n     * A function that returns the first truthy of two arguments otherwise the\n     * last argument. Note that this is NOT short-circuited, meaning that if\n     * expressions are passed they are both evaluated.\n     *\n     * Dispatches to the `or` method of the first argument if applicable.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig * -> * -> *\n     * @param {*} a any value\n     * @param {*} b any other value\n     * @return {*} the first truthy argument, otherwise the last argument.\n     * @see R.either\n     * @example\n     *\n     *      R.or(false, true); //=> true\n     *      R.or(0, []); //=> []\n     *      R.or(null, ''); => ''\n     */\n    var or = _curry2(function or(a, b) {\n        return _hasMethod('or', a) ? a.or(b) : a || b;\n    });\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values prepended to the\n     * original function's arguments list. In some libraries this function is named `applyLeft`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to prepend to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn`\n     *         with `args` prepended to `fn`'s arguments list.\n     * @example\n     *\n     *      var multiply = function(a, b) { return a * b; };\n     *      var double = R.partial(multiply, 2);\n     *      double(2); //=> 4\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var sayHello = R.partial(greet, 'Hello');\n     *      var sayHelloToMs = R.partial(sayHello, 'Ms.');\n     *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partial = curry(_createPartialApplicator(_concat));\n\n    /**\n     * Accepts as its arguments a function and any number of values and returns a function that,\n     * when invoked, calls the original function with all of the values appended to the original\n     * function's arguments list.\n     *\n     * Note that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\n     * from the right to the left.  In some libraries this function is named `applyRight`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)\n     * @param {Function} fn The function to invoke.\n     * @param {...*} [args] Arguments to append to `fn` when the returned function is invoked.\n     * @return {Function} A new function wrapping `fn`. When invoked, it will call `fn` with\n     *         `args` appended to `fn`'s arguments list.\n     * @example\n     *\n     *      var greet = function(salutation, title, firstName, lastName) {\n     *        return salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n     *      };\n     *      var greetMsJaneJones = R.partialRight(greet, 'Ms.', 'Jane', 'Jones');\n     *\n     *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n     */\n    var partialRight = curry(_createPartialApplicator(flip(_concat)));\n\n    /**\n     * Takes a predicate and a list and returns the pair of lists of\n     * elements which do and do not satisfy the predicate, respectively.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [[a],[a]]\n     * @param {Function} pred A predicate to determine which array the element belongs to.\n     * @param {Array} list The array to partition.\n     * @return {Array} A nested array, containing first an array of elements that satisfied the predicate,\n     *         and second an array of elements that did not satisfy.\n     * @example\n     *\n     *      R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n     *      //=> [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n     */\n    var partition = _curry2(function partition(pred, list) {\n        return _reduce(function (acc, elt) {\n            var xs = acc[pred(elt) ? 0 : 1];\n            xs[xs.length] = elt;\n            return acc;\n        }, [\n            [],\n            []\n        ], list);\n    });\n\n    /**\n     * Determines whether a nested path on an object has a specific value,\n     * in `R.equals` terms. Most likely used to filter a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [String] -> * -> {String: *} -> Boolean\n     * @param {Array} path The path of the nested property to use\n     * @param {*} val The value to compare the nested property with\n     * @param {Object} obj The object to check the nested property in\n     * @return {Boolean} `true` if the value equals the nested object property,\n     *         `false` otherwise.\n     * @example\n     *\n     *      var user1 = { address: { zipCode: 90210 } };\n     *      var user2 = { address: { zipCode: 55555 } };\n     *      var user3 = { name: 'Bob' };\n     *      var users = [ user1, user2, user3 ];\n     *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n     *      R.filter(isFamous, users); //=> [ user1 ]\n     */\n    var pathEq = _curry3(function pathEq(_path, val, obj) {\n        return equals(path(_path, obj), val);\n    });\n\n    /**\n     * Returns a new list by plucking the same named property off all objects in the list supplied.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig k -> [{k: v}] -> [v]\n     * @param {Number|String} key The key name to pluck off of each object.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of values for the given key.\n     * @example\n     *\n     *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n     *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n     */\n    var pluck = _curry2(function pluck(p, list) {\n        return map(prop(p), list);\n    });\n\n    /**\n     * Returns `true` if the specified object property is equal, in `R.equals`\n     * terms, to the given value; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig String -> a -> Object -> Boolean\n     * @param {String} name\n     * @param {*} val\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.equals, R.propSatisfies\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n     *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n     *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n     *      var kids = [abby, fred, rusty, alois];\n     *      var hasBrownHair = R.propEq('hair', 'brown');\n     *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n     */\n    var propEq = _curry3(function propEq(name, val, obj) {\n        return propSatisfies(equals(val), name, obj);\n    });\n\n    /**\n     * Returns `true` if the specified object property is of the given type;\n     * `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category Type\n     * @sig Type -> String -> Object -> Boolean\n     * @param {Function} type\n     * @param {String} name\n     * @param {*} obj\n     * @return {Boolean}\n     * @see R.is\n     * @see R.propSatisfies\n     * @example\n     *\n     *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n     *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n     *      R.propIs(Number, 'x', {});            //=> false\n     */\n    var propIs = _curry3(function propIs(type, name, obj) {\n        return propSatisfies(is(type), name, obj);\n    });\n\n    /**\n     * Returns a single item by iterating through the list, successively calling the iterator\n     * function and passing it an accumulator value and the current value from the array, and\n     * then passing the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n     * shortcut the iteration.\n     *\n     * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n     * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n     * @see R.reduced\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a,b -> a) -> a -> [b] -> a\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array.\n     * @param {*} acc The accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3];\n     *      var add = function(a, b) {\n     *        return a + b;\n     *      };\n     *\n     *      R.reduce(add, 10, numbers); //=> 16\n     */\n    var reduce = _curry3(_reduce);\n\n    /**\n     * Similar to `filter`, except that it keeps only values for which the given predicate\n     * function returns falsy. The predicate function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} The new filtered array.\n     * @see R.filter\n     * @example\n     *\n     *      var isOdd = function(n) {\n     *        return n % 2 === 1;\n     *      };\n     *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n     */\n    var reject = _curry2(function reject(fn, list) {\n        return filter(_complement(fn), list);\n    });\n\n    /**\n     * Returns a fixed list of size `n` containing a specified identical value.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> n -> [a]\n     * @param {*} value The value to repeat.\n     * @param {Number} n The desired size of the output list.\n     * @return {Array} A new array containing `n` `value`s.\n     * @example\n     *\n     *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n     *\n     *      var obj = {};\n     *      var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n     *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n     */\n    var repeat = _curry2(function repeat(value, n) {\n        return times(always(value), n);\n    });\n\n    /**\n     * Returns the elements of the given list or string (or object with a `slice`\n     * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> Number -> [a] -> [a]\n     * @sig Number -> Number -> String -> String\n     * @param {Number} fromIndex The start index (inclusive).\n     * @param {Number} toIndex The end index (exclusive).\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n     *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n     *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n     *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n     *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n     */\n    var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n        return Array.prototype.slice.call(list, fromIndex, toIndex);\n    }));\n\n    /**\n     * Splits a collection into slices of the specified length.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [[a]]\n     * @sig Number -> String -> [String]\n     * @param {Number} n\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n     *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n     */\n    var splitEvery = _curry2(function splitEvery(n, list) {\n        if (n <= 0) {\n            throw new Error('First argument to splitEvery must be a positive integer');\n        }\n        var result = [];\n        var idx = 0;\n        while (idx < list.length) {\n            result.push(slice(idx, idx += n, list));\n        }\n        return result;\n    });\n\n    /**\n     * Adds together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The sum of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.sum([2,4,6,8,100,1]); //=> 121\n     */\n    var sum = reduce(add, 0);\n\n    /**\n     * Returns all but the first element of the given list or string (or object\n     * with a `tail` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.head, R.init, R.last\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.tail([1, 2, 3]);  //=> [2, 3]\n     *      R.tail([1, 2]);     //=> [2]\n     *      R.tail([1]);        //=> []\n     *      R.tail([]);         //=> []\n     *\n     *      R.tail('abc');  //=> 'bc'\n     *      R.tail('ab');   //=> 'b'\n     *      R.tail('a');    //=> ''\n     *      R.tail('');     //=> ''\n     */\n    var tail = _checkForMethod('tail', slice(1, Infinity));\n\n    /**\n     * Returns the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `take` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.drop\n     * @example\n     *\n     *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.take(3, 'ramda');               //=> 'ram'\n     *\n     *      var personnel = [\n     *        'Dave Brubeck',\n     *        'Paul Desmond',\n     *        'Eugene Wright',\n     *        'Joe Morello',\n     *        'Gerry Mulligan',\n     *        'Bob Bates',\n     *        'Joe Dodge',\n     *        'Ron Crotty'\n     *      ];\n     *\n     *      var takeFive = R.take(5);\n     *      takeFive(personnel);\n     *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n     */\n    var take = _curry2(_dispatchable('take', _xtake, function take(n, xs) {\n        return slice(0, n < 0 ? Infinity : n, xs);\n    }));\n\n    /**\n     * Returns a new list containing the first `n` elements of a given list, passing each value\n     * to the supplied predicate function, and terminating when the predicate function returns\n     * `false`. Excludes the element that caused the predicate function to fail. The predicate\n     * function is passed one argument: *(value)*.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> Boolean) -> [a] -> [a]\n     * @param {Function} fn The function called per iteration.\n     * @param {Array} list The collection to iterate over.\n     * @return {Array} A new array.\n     * @see R.dropWhile\n     * @example\n     *\n     *      var isNotFour = function(x) {\n     *        return !(x === 4);\n     *      };\n     *\n     *      R.takeWhile(isNotFour, [1, 2, 3, 4]); //=> [1, 2, 3]\n     */\n    var takeWhile = _curry2(_dispatchable('takeWhile', _xtakeWhile, function takeWhile(fn, list) {\n        var idx = 0, len = list.length;\n        while (idx < len && fn(list[idx])) {\n            idx += 1;\n        }\n        return _slice(list, 0, idx);\n    }));\n\n    /**\n     * Initializes a transducer using supplied iterator function. Returns a single item by\n     * iterating through the list, successively calling the transformed iterator function and\n     * passing it an accumulator value and the current value from the array, and then passing\n     * the result to the next call.\n     *\n     * The iterator function receives two values: *(acc, value)*. It will be wrapped as a\n     * transformer to initialize the transducer. A transformer can be passed directly in place\n     * of an iterator function.  In both cases, iteration may be stopped early with the\n     * `R.reduced` function.\n     *\n     * A transducer is a function that accepts a transformer and returns a transformer and can\n     * be composed directly.\n     *\n     * A transformer is an an object that provides a 2-arity reducing iterator function, step,\n     * 0-arity initial value function, init, and 1-arity result extraction function, result.\n     * The step function is used as the iterator function in reduce. The result function is used\n     * to convert the final accumulator into the return type and in most cases is R.identity.\n     * The init function can be used to provide an initial accumulator, but is ignored by transduce.\n     *\n     * The iteration is performed with R.reduce after initializing the transducer.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.reduce, R.reduced, R.into\n     * @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a\n     * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n     * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n     *        current element from the array. Wrapped as transformer, if necessary, and used to\n     *        initialize the transducer\n     * @param {*} acc The initial accumulator value.\n     * @param {Array} list The list to iterate over.\n     * @return {*} The final, accumulated value.\n     * @example\n     *\n     *      var numbers = [1, 2, 3, 4];\n     *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n     *\n     *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n     */\n    var transduce = curryN(4, function transduce(xf, fn, acc, list) {\n        return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\n     * determined according to the value returned by applying the supplied predicate to two list elements.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig (a,a -> Boolean) -> [a] -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @see R.union\n     * @example\n     *\n     *      function cmp(x, y) { return x.a === y.a; }\n     *      var l1 = [{a: 1}, {a: 2}];\n     *      var l2 = [{a: 1}, {a: 4}];\n     *      R.unionWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n     */\n    var unionWith = _curry3(function unionWith(pred, list1, list2) {\n        return uniqWith(pred, _concat(list1, list2));\n    });\n\n    /**\n     * Returns a new list containing only one copy of each element in the original list.\n     * `R.equals` is used to determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n     *      R.uniq([1, '1']);     //=> [1, '1']\n     *      R.uniq([[42], [42]]); //=> [[42]]\n     */\n    var uniq = uniqWith(equals);\n\n    /**\n     * Returns a new list by pulling every item at the first level of nesting out, and putting\n     * them in a new array.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [b]\n     * @param {Array} list The array to consider.\n     * @return {Array} The flattened list.\n     * @see R.flatten\n     * @example\n     *\n     *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n     *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n     */\n    var unnest = _curry1(_makeFlat(false));\n\n    /**\n     * Accepts a function `fn` and any number of transformer functions and returns a new\n     * function. When the new function is invoked, it calls the function `fn` with parameters\n     * consisting of the result of calling each supplied handler on successive arguments to the\n     * new function.\n     *\n     * If more arguments are passed to the returned function than transformer functions, those\n     * arguments are passed directly to `fn` as additional parameters. If you expect additional\n     * arguments that don't need to be transformed, although you can ignore them, it's best to\n     * pass an identity function so that the new function reports the correct arity.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} fn The function to wrap.\n     * @param {...Function} transformers A variable number of transformer functions\n     * @return {Function} The wrapped function.\n     * @example\n     *\n     *      var double = function(y) { return y * 2; };\n     *      var square = function(x) { return x * x; };\n     *      var add = function(a, b) { return a + b; };\n     *      // Adds any number of arguments together\n     *      var addAll = function() {\n     *        return R.reduce(add, 0, arguments);\n     *      };\n     *\n     *      // Basic example\n     *      var addDoubleAndSquare = R.useWith(addAll, double, square);\n     *\n     *      //≅ addAll(double(10), square(5));\n     *      addDoubleAndSquare(10, 5); //=> 45\n     *\n     *      // Example of passing more arguments than transformers\n     *      //≅ addAll(double(10), square(5), 100);\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     *\n     *      // If there are extra _expected_ arguments that don't need to be transformed, although\n     *      // you can ignore them, it might be best to pass in the identity function so that the new\n     *      // function correctly reports arity.\n     *      var addDoubleAndSquareWithExtraParams = R.useWith(addAll, double, square, R.identity);\n     *      // addDoubleAndSquareWithExtraParams.length //=> 3\n     *      //≅ addAll(double(10), square(5), R.identity(100));\n     *      addDoubleAndSquare(10, 5, 100); //=> 145\n     */\n    /*, transformers */\n    var useWith = curry(function useWith(fn) {\n        var transformers = _slice(arguments, 1);\n        var tlen = transformers.length;\n        return curry(_arity(tlen, function () {\n            var args = [], idx = 0;\n            while (idx < tlen) {\n                args[idx] = transformers[idx](arguments[idx]);\n                idx += 1;\n            }\n            return fn.apply(this, args.concat(_slice(arguments, tlen)));\n        }));\n    });\n\n    /**\n     * Takes a spec object and a test object; returns true if the test satisfies\n     * the spec, false otherwise. An object satisfies the spec if, for each of the\n     * spec's own properties, accessing that property of the object gives the same\n     * value (in `R.equals` terms) as accessing that property of the spec.\n     *\n     * `whereEq` is a specialization of [`where`](#where).\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig {String: *} -> {String: *} -> Boolean\n     * @param {Object} spec\n     * @param {Object} testObj\n     * @return {Boolean}\n     * @see R.where\n     * @example\n     *\n     *      // pred :: Object -> Boolean\n     *      var pred = R.whereEq({a: 1, b: 2});\n     *\n     *      pred({a: 1});              //=> false\n     *      pred({a: 1, b: 2});        //=> true\n     *      pred({a: 1, b: 2, c: 3});  //=> true\n     *      pred({a: 1, b: 1});        //=> false\n     */\n    var whereEq = _curry2(function whereEq(spec, testObj) {\n        return where(mapObj(equals, spec), testObj);\n    });\n\n    var _flatCat = function () {\n        var preservingReduced = function (xf) {\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return xf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    var ret = xf['@@transducer/step'](result, input);\n                    return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n                }\n            };\n        };\n        return function _xcat(xf) {\n            var rxf = preservingReduced(xf);\n            return {\n                '@@transducer/init': _xfBase.init,\n                '@@transducer/result': function (result) {\n                    return rxf['@@transducer/result'](result);\n                },\n                '@@transducer/step': function (result, input) {\n                    return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n                }\n            };\n        };\n    }();\n\n    var _indexOf = function _indexOf(list, item, from) {\n        var idx = from;\n        while (idx < list.length) {\n            if (equals(list[idx], item)) {\n                return idx;\n            }\n            idx += 1;\n        }\n        return -1;\n    };\n\n    /**\n     * Create a predicate wrapper which will call a pick function (all/any) for each predicate\n     *\n     * @private\n     * @see R.all\n     * @see R.any\n     */\n    // Call function immediately if given arguments\n    // Return a function which will call the predicates with the provided arguments\n    var _predicateWrap = function _predicateWrap(predPicker) {\n        return function (preds) {\n            var predIterator = function () {\n                var args = arguments;\n                return predPicker(function (predicate) {\n                    return predicate.apply(null, args);\n                }, preds);\n            };\n            return arguments.length > 1 ? // Call function immediately if given arguments\n            predIterator.apply(null, _slice(arguments, 1)) : // Return a function which will call the predicates with the provided arguments\n            _arity(Math.max.apply(Math, pluck('length', preds)), predIterator);\n        };\n    };\n\n    var _xchain = _curry2(function _xchain(f, xf) {\n        return map(f, _flatCat(xf));\n    });\n\n    /**\n     * Given a list of predicates, returns a new predicate that will be true exactly when all of them are.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} a function that applies its arguments to each of\n     *         the predicates, returning `true` if all are satisfied.\n     * @see R.anyPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.allPass([gt10, even]);\n     *      f(11); //=> false\n     *      f(12); //=> true\n     */\n    var allPass = _curry1(_predicateWrap(all));\n\n    /**\n     * Given a list of predicates returns a new predicate that will be true exactly when any one of them is.\n     *\n     * @func\n     * @memberOf R\n     * @category Logic\n     * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n     * @param {Array} list An array of predicate functions\n     * @param {*} optional Any arguments to pass into the predicates\n     * @return {Function} A function that applies its arguments to each of the predicates, returning\n     *         `true` if all are satisfied.\n     * @see R.allPass\n     * @example\n     *\n     *      var gt10 = function(x) { return x > 10; };\n     *      var even = function(x) { return x % 2 === 0};\n     *      var f = R.anyPass([gt10, even]);\n     *      f(11); //=> true\n     *      f(8); //=> true\n     *      f(9); //=> false\n     */\n    var anyPass = _curry1(_predicateWrap(any));\n\n    /**\n     * ap applies a list of functions to a list of values.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig [f] -> [a] -> [f a]\n     * @param {Array} fns An array of functions\n     * @param {Array} vs An array of values\n     * @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.\n     * @example\n     *\n     *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n     */\n    var ap = _curry2(function ap(fns, vs) {\n        return _hasMethod('ap', fns) ? fns.ap(vs) : _reduce(function (acc, fn) {\n            return _concat(acc, map(fn, vs));\n        }, [], fns);\n    });\n\n    /**\n     * Returns the result of calling its first argument with the remaining\n     * arguments. This is occasionally useful as a converging function for\n     * `R.converge`: the left branch can produce a function while the right\n     * branch produces a value to be passed to that function as an argument.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a),*... -> a\n     * @param {Function} fn The function to apply to the remaining arguments.\n     * @param {...*} args Any number of positional arguments.\n     * @return {*}\n     * @see R.apply\n     * @example\n     *\n     *      var indentN = R.pipe(R.times(R.always(' ')),\n     *                           R.join(''),\n     *                           R.replace(/^(?!$)/gm));\n     *\n     *      var format = R.converge(R.call,\n     *                              R.pipe(R.prop('indent'), indentN),\n     *                              R.prop('value'));\n     *\n     *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n     */\n    var call = curry(function call(fn) {\n        return fn.apply(this, _slice(arguments, 1));\n    });\n\n    /**\n     * `chain` maps a function over a list and concatenates the results.\n     * This implementation is compatible with the\n     * Fantasy-land Chain spec, and will work with types that implement that spec.\n     * `chain` is also known as `flatMap` in some libraries\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> [b]) -> [a] -> [b]\n     * @param {Function} fn\n     * @param {Array} list\n     * @return {Array}\n     * @example\n     *\n     *      var duplicate = function(n) {\n     *        return [n, n];\n     *      };\n     *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n     */\n    var chain = _curry2(_dispatchable('chain', _xchain, function chain(fn, list) {\n        return unnest(map(fn, list));\n    }));\n\n    /**\n     * Turns a list of Functors into a Functor of a list, applying\n     * a mapping function to the elements of the list along the way.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commute\n     * @sig Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]\n     * @param {Function} fn The transformation function\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2, 3]]);   //=> [[11, 12], [11, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1, 2], [3]]);   //=> [[11, 13], [12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), R.of, [[1], [2], [3]]); //=> [[11, 12, 13]]\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([11, 12, 13])\n     *      R.commuteMap(R.map(R.add(10)), Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commuteMap = _curry3(function commuteMap(fn, of, list) {\n        function consF(acc, ftor) {\n            return ap(map(append, fn(ftor)), acc);\n        }\n        return _reduce(consF, of([]), list);\n    });\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type. The arity of the function returned is specified\n     * to allow using variadic constructor functions.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> (* -> {*}) -> (* -> {*})\n     * @param {Number} n The arity of the constructor function.\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Variadic constructor function\n     *      var Widget = function() {\n     *        this.children = Array.prototype.slice.call(arguments);\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.constructN(1, Widget), allConfigs); // a list of Widgets\n     */\n    var constructN = _curry2(function constructN(n, Fn) {\n        if (n > 10) {\n            throw new Error('Constructor with greater than ten arguments');\n        }\n        if (n === 0) {\n            return function () {\n                return new Fn();\n            };\n        }\n        return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n            switch (arguments.length) {\n            case 1:\n                return new Fn($0);\n            case 2:\n                return new Fn($0, $1);\n            case 3:\n                return new Fn($0, $1, $2);\n            case 4:\n                return new Fn($0, $1, $2, $3);\n            case 5:\n                return new Fn($0, $1, $2, $3, $4);\n            case 6:\n                return new Fn($0, $1, $2, $3, $4, $5);\n            case 7:\n                return new Fn($0, $1, $2, $3, $4, $5, $6);\n            case 8:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n            case 9:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n            case 10:\n                return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n            }\n        }));\n    });\n\n    /**\n     * Accepts at least three functions and returns a new function. When invoked, this new\n     * function will invoke the first function, `after`, passing as its arguments the\n     * results of invoking the subsequent functions with whatever arguments are passed to\n     * the new function.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)\n     * @param {Function} after A function. `after` will be invoked with the return values of\n     *        `fn1` and `fn2` as its arguments.\n     * @param {...Function} functions A variable number of functions.\n     * @return {Function} A new function.\n     * @example\n     *\n     *      var add = function(a, b) { return a + b; };\n     *      var multiply = function(a, b) { return a * b; };\n     *      var subtract = function(a, b) { return a - b; };\n     *\n     *      //≅ multiply( add(1, 2), subtract(1, 2) );\n     *      R.converge(multiply, add, subtract)(1, 2); //=> -3\n     *\n     *      var add3 = function(a, b, c) { return a + b + c; };\n     *      R.converge(add3, multiply, add, subtract)(1, 2); //=> 4\n     */\n    var converge = curryN(3, function converge(after) {\n        var fns = _slice(arguments, 1);\n        return curryN(Math.max.apply(Math, pluck('length', fns)), function () {\n            var args = arguments;\n            var context = this;\n            return after.apply(context, _map(function (fn) {\n                return fn.apply(context, args);\n            }, fns));\n        });\n    });\n\n    /**\n     * Returns all but the first `n` elements of the given list, string, or\n     * transducer/transformer (or object with a `drop` method).\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.transduce\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n\n     * @param {*} list\n     * @return {*}\n     * @see R.take\n     * @example\n     *\n     *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n     *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.drop(3, 'ramda');               //=> 'da'\n     */\n    var drop = _curry2(_dispatchable('drop', _xdrop, function drop(n, xs) {\n        return slice(Math.max(0, n), Infinity, xs);\n    }));\n\n    /**\n     * Returns a list containing all but the last `n` elements of the given `list`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements of `xs` to skip.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.takeLast\n     * @example\n     *\n     *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n     *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n     *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n     *      R.dropLast(3, 'ramda');               //=> 'ra'\n     */\n    var dropLast = _curry2(function dropLast(n, xs) {\n        return take(n < xs.length ? xs.length - n : 0, xs);\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements. Equality is\n     * determined by applying the supplied predicate two consecutive elements.\n     * The first element in a series of equal element is the one being preserved.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a, a -> Boolean) -> [a] -> [a]\n     * @param {Function} pred A predicate used to test whether two items are equal.\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *      function lengthEq(x, y) { return Math.abs(x) === Math.abs(y); };\n     *      var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n     *      R.dropRepeatsWith(lengthEq, l); //=> [1, 3, 4, -5, 3]\n     */\n    var dropRepeatsWith = _curry2(_dispatchable('dropRepeatsWith', _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n        var result = [];\n        var idx = 1;\n        var len = list.length;\n        if (len !== 0) {\n            result[0] = list[0];\n            while (idx < len) {\n                if (!pred(last(result), list[idx])) {\n                    result[result.length] = list[idx];\n                }\n                idx += 1;\n            }\n        }\n        return result;\n    }));\n\n    /**\n     * Reports whether two objects have the same value, in `R.equals` terms,\n     * for the specified property. Useful as a curried predicate.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig k -> {k: v} -> {k: v} -> Boolean\n     * @param {String} prop The name of the property to compare\n     * @param {Object} obj1\n     * @param {Object} obj2\n     * @return {Boolean}\n     *\n     * @example\n     *\n     *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n     *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n     *      R.eqProps('a', o1, o2); //=> false\n     *      R.eqProps('c', o1, o2); //=> true\n     */\n    var eqProps = _curry3(function eqProps(prop, obj1, obj2) {\n        return equals(obj1[prop], obj2[prop]);\n    });\n\n    /**\n     * Returns the position of the first occurrence of an item in an array,\n     * or -1 if the item is not included in the array. `R.equals` is used to\n     * determine equality.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Number\n     * @param {*} target The item to find.\n     * @param {Array} xs The array to search in.\n     * @return {Number} the index of the target, or -1 if the target is not found.\n     * @see R.lastIndexOf\n     * @example\n     *\n     *      R.indexOf(3, [1,2,3,4]); //=> 2\n     *      R.indexOf(10, [1,2,3,4]); //=> -1\n     */\n    var indexOf = _curry2(function indexOf(target, xs) {\n        return _hasMethod('indexOf', xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n    });\n\n    /**\n     * Returns all but the last element of the given list or string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.last, R.head, R.tail\n     * @sig [a] -> [a]\n     * @sig String -> String\n     * @param {*} list\n     * @return {*}\n     * @example\n     *\n     *      R.init([1, 2, 3]);  //=> [1, 2]\n     *      R.init([1, 2]);     //=> [1]\n     *      R.init([1]);        //=> []\n     *      R.init([]);         //=> []\n     *\n     *      R.init('abc');  //=> 'ab'\n     *      R.init('ab');   //=> 'a'\n     *      R.init('a');    //=> ''\n     *      R.init('');     //=> ''\n     */\n    var init = slice(0, -1);\n\n    /**\n     * Returns `true` if all elements are unique, in `R.equals` terms,\n     * otherwise `false`.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> Boolean\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if all elements are unique, else `false`.\n     * @example\n     *\n     *      R.isSet(['1', 1]); //=> true\n     *      R.isSet([1, 1]);   //=> false\n     *      R.isSet([[42], [42]]); //=> false\n     */\n    var isSet = _curry1(function isSet(list) {\n        var len = list.length;\n        var idx = 0;\n        while (idx < len) {\n            if (_indexOf(list, list[idx], idx + 1) >= 0) {\n                return false;\n            }\n            idx += 1;\n        }\n        return true;\n    });\n\n    /**\n     * Returns a lens for the given getter and setter functions. The getter \"gets\"\n     * the value of the focus; the setter \"sets\" the value of the focus. The setter\n     * should not mutate the data structure.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n     * @param {Function} getter\n     * @param {Function} setter\n     * @return {Lens}\n     * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n     * @example\n     *\n     *      var xLens = R.lens(R.prop('x'), R.assoc('x'));\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lens = _curry2(function lens(getter, setter) {\n        return function (f) {\n            return function (s) {\n                return map(function (v) {\n                    return setter(v, s);\n                }, f(getter(s)));\n            };\n        };\n    });\n\n    /**\n     * Returns a lens whose focus is the specified index.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig Number -> Lens s a\n     * @param {Number} n\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var headLens = R.lensIndex(0);\n     *\n     *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n     *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n     *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n     */\n    var lensIndex = _curry1(function lensIndex(n) {\n        return lens(nth(n), update(n));\n    });\n\n    /**\n     * Returns a lens whose focus is the specified property.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s\n     * @sig String -> Lens s a\n     * @param {String} k\n     * @return {Lens}\n     * @see R.view, R.set, R.over\n     * @example\n     *\n     *      var xLens = R.lensProp('x');\n     *\n     *      R.view(xLens, {x: 1, y: 2});            //=> 1\n     *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n     *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n     */\n    var lensProp = _curry1(function lensProp(k) {\n        return lens(prop(k), assoc(k));\n    });\n\n    /**\n     * \"lifts\" a function to be the specified arity, so that it may \"map over\" that many\n     * lists (or other Functors).\n     *\n     * @func\n     * @memberOf R\n     * @see R.lift\n     * @category Function\n     * @sig Number -> (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.liftN(3, R.curryN(3, function() {\n     *        return R.reduce(R.add, 0, arguments);\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     */\n    var liftN = _curry2(function liftN(arity, fn) {\n        var lifted = curryN(arity, fn);\n        return curryN(arity, function () {\n            return _reduce(ap, map(lifted, arguments[0]), _slice(arguments, 1));\n        });\n    });\n\n    /**\n     * Returns the mean of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.mean([2, 7, 9]); //=> 6\n     *      R.mean([]); //=> NaN\n     */\n    var mean = _curry1(function mean(list) {\n        return sum(list) / list.length;\n    });\n\n    /**\n     * Returns the median of the given list of numbers.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list\n     * @return {Number}\n     * @example\n     *\n     *      R.median([2, 9, 7]); //=> 7\n     *      R.median([7, 2, 10, 9]); //=> 8\n     *      R.median([]); //=> NaN\n     */\n    var median = _curry1(function median(list) {\n        var len = list.length;\n        if (len === 0) {\n            return NaN;\n        }\n        var width = 2 - len % 2;\n        var idx = (len - width) / 2;\n        return mean(_slice(list).sort(function (a, b) {\n            return a < b ? -1 : a > b ? 1 : 0;\n        }).slice(idx, idx + width));\n    });\n\n    /**\n     * Merges a list of objects together into one object.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [{k: v}] -> {k: v}\n     * @param {Array} list An array of objects\n     * @return {Object} A merged object.\n     * @see R.reduce\n     * @example\n     *\n     *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n     *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n     */\n    var mergeAll = _curry1(function mergeAll(list) {\n        return reduce(merge, {}, list);\n    });\n\n    /**\n     * Performs left-to-right function composition. The leftmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * In some libraries this function is named `sequence`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.compose\n     * @example\n     *\n     *      var f = R.pipe(Math.pow, R.negate, R.inc);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var pipe = function pipe() {\n        if (arguments.length === 0) {\n            throw new Error('pipe requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Performs left-to-right composition of one or more Promise-returning\n     * functions. The leftmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.composeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n     */\n    var pipeP = function pipeP() {\n        if (arguments.length === 0) {\n            throw new Error('pipeP requires at least one argument');\n        }\n        return curryN(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n    };\n\n    /**\n     * Multiplies together all the elements of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category Math\n     * @sig [Number] -> Number\n     * @param {Array} list An array of numbers\n     * @return {Number} The product of all the numbers in the list.\n     * @see R.reduce\n     * @example\n     *\n     *      R.product([2,4,6,8,100,1]); //=> 38400\n     */\n    var product = reduce(multiply, 1);\n\n    /**\n     * Reasonable analog to SQL `select` statement.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @category Relation\n     * @sig [k] -> [{k: v}] -> [{k: v}]\n     * @param {Array} props The property names to project\n     * @param {Array} objs The objects to query\n     * @return {Array} An array of objects with just the `props` properties.\n     * @example\n     *\n     *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n     *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n     *      var kids = [abby, fred];\n     *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n     */\n    // passing `identity` gives correct arity\n    var project = useWith(_map, pickAll, identity);\n\n    /**\n     * Returns a new list containing the last `n` elements of the given list.\n     * If `n > list.length`, returns a list of `list.length` elements.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig Number -> [a] -> [a]\n     * @sig Number -> String -> String\n     * @param {Number} n The number of elements to return.\n     * @param {Array} xs The collection to consider.\n     * @return {Array}\n     * @see R.dropLast\n     * @example\n     *\n     *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n     *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['for', 'baz']\n     *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n     *      R.takeLast(3, 'ramda');               //=> 'mda'\n     */\n    var takeLast = _curry2(function takeLast(n, xs) {\n        return drop(n >= 0 ? xs.length - n : 0, xs);\n    });\n\n    var _contains = function _contains(a, list) {\n        return _indexOf(list, a, 0) >= 0;\n    };\n\n    //  mapPairs :: (Object, [String]) -> [String]\n    // Function, RegExp, user-defined types\n    var _toString = function _toString(x, seen) {\n        var recur = function recur(y) {\n            var xs = seen.concat([x]);\n            return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n        };\n        //  mapPairs :: (Object, [String]) -> [String]\n        var mapPairs = function (obj, keys) {\n            return _map(function (k) {\n                return _quote(k) + ': ' + recur(obj[k]);\n            }, keys.slice().sort());\n        };\n        switch (Object.prototype.toString.call(x)) {\n        case '[object Arguments]':\n            return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n        case '[object Array]':\n            return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n        case '[object Boolean]':\n            return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n        case '[object Date]':\n            return 'new Date(' + _quote(_toISOString(x)) + ')';\n        case '[object Null]':\n            return 'null';\n        case '[object Number]':\n            return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n        case '[object String]':\n            return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n        case '[object Undefined]':\n            return 'undefined';\n        default:\n            return typeof x.constructor === 'function' && x.constructor.name !== 'Object' && typeof x.toString === 'function' && x.toString() !== '[object Object]' ? x.toString() : // Function, RegExp, user-defined types\n            '{' + mapPairs(x, keys(x)).join(', ') + '}';\n        }\n    };\n\n    /**\n     * Turns a list of Functors into a Functor of a list.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @see R.commuteMap\n     * @sig Functor f => (x -> f x) -> [f a] -> f [a]\n     * @param {Function} of A function that returns the data type to return\n     * @param {Array} list An array of functors of the same type\n     * @return {*}\n     * @example\n     *\n     *      R.commute(R.of, [[1], [2, 3]]);   //=> [[1, 2], [1, 3]]\n     *      R.commute(R.of, [[1, 2], [3]]);   //=> [[1, 3], [2, 3]]\n     *      R.commute(R.of, [[1], [2], [3]]); //=> [[1, 2, 3]]\n     *      R.commute(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n     *      R.commute(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n     */\n    var commute = commuteMap(identity);\n\n    /**\n     * Performs right-to-left function composition. The rightmost function may have\n     * any arity; the remaining functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipe\n     * @example\n     *\n     *      var f = R.compose(R.inc, R.negate, Math.pow);\n     *\n     *      f(3, 4); // -(3^4) + 1\n     */\n    var compose = function compose() {\n        if (arguments.length === 0) {\n            throw new Error('compose requires at least one argument');\n        }\n        return pipe.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the right-to-left Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.pipeK\n     * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.composeK(\n     *        R.compose(Maybe.of, R.toUpper),\n     *        get('state'),\n     *        get('address'),\n     *        get('user'),\n     *        parseJson\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var composeK = function composeK() {\n        return arguments.length === 0 ? identity : compose.apply(this, map(chain, arguments));\n    };\n\n    /**\n     * Performs right-to-left composition of one or more Promise-returning\n     * functions. The rightmost function may have any arity; the remaining\n     * functions must be unary.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n     * @param {...Function} functions\n     * @return {Function}\n     * @see R.pipeP\n     * @example\n     *\n     *      //  followersForUser :: String -> Promise [User]\n     *      var followersForUser = R.composeP(db.getFollowers, db.getUserById);\n     */\n    var composeP = function composeP() {\n        if (arguments.length === 0) {\n            throw new Error('composeP requires at least one argument');\n        }\n        return pipeP.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Wraps a constructor function inside a curried function that can be called with the same\n     * arguments and returns the same type.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (* -> {*}) -> (* -> {*})\n     * @param {Function} Fn The constructor function to wrap.\n     * @return {Function} A wrapped, curried constructor function.\n     * @example\n     *\n     *      // Constructor function\n     *      var Widget = function(config) {\n     *        // ...\n     *      };\n     *      Widget.prototype = {\n     *        // ...\n     *      };\n     *      var allConfigs = [\n     *        // ...\n     *      ];\n     *      R.map(R.construct(Widget), allConfigs); // a list of Widgets\n     */\n    var construct = _curry1(function construct(Fn) {\n        return constructN(Fn.length, Fn);\n    });\n\n    /**\n     * Returns `true` if the specified value is equal, in `R.equals` terms,\n     * to at least one element of the given list; `false` otherwise.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig a -> [a] -> Boolean\n     * @param {Object} a The item to compare against.\n     * @param {Array} list The array to consider.\n     * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n     *\n     * @example\n     *\n     *      R.contains(3, [1, 2, 3]); //=> true\n     *      R.contains(4, [1, 2, 3]); //=> false\n     *      R.contains([42], [[42]]); //=> true\n     */\n    var contains = _curry2(_contains);\n\n    /**\n     * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @return {Array} The elements in `list1` that are not in `list2`.\n     * @see R.differenceWith\n     * @example\n     *\n     *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n     *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n     */\n    var difference = _curry2(function difference(first, second) {\n        var out = [];\n        var idx = 0;\n        var firstLen = first.length;\n        while (idx < firstLen) {\n            if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n                out[out.length] = first[idx];\n            }\n            idx += 1;\n        }\n        return out;\n    });\n\n    /**\n     * Returns a new list without any consecutively repeating elements.\n     * `R.equals` is used to determine equality.\n     *\n     * Acts as a transducer if a transformer is given in list position.\n     * @see R.transduce\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig [a] -> [a]\n     * @param {Array} list The array to consider.\n     * @return {Array} `list` without repeating elements.\n     * @example\n     *\n     *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n     */\n    var dropRepeats = _curry1(_dispatchable('dropRepeats', _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} list1 The first list.\n     * @param {Array} list2 The second list.\n     * @see R.intersectionWith\n     * @return {Array} The list of elements found in both `list1` and `list2`.\n     * @example\n     *\n     *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n     */\n    var intersection = _curry2(function intersection(list1, list2) {\n        return uniq(_filter(flip(_contains)(list1), list2));\n    });\n\n    /**\n     * \"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\n     * other Functor.\n     *\n     * @func\n     * @memberOf R\n     * @see R.liftN\n     * @category Function\n     * @sig (*... -> *) -> ([*]... -> [*])\n     * @param {Function} fn The function to lift into higher context\n     * @return {Function} The function `fn` applicable to mappable objects.\n     * @example\n     *\n     *      var madd3 = R.lift(R.curry(function(a, b, c) {\n     *        return a + b + c;\n     *      }));\n     *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n     *\n     *      var madd5 = R.lift(R.curry(function(a, b, c, d, e) {\n     *        return a + b + c + d + e;\n     *      }));\n     *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n     */\n    var lift = _curry1(function lift(fn) {\n        return liftN(fn.length, fn);\n    });\n\n    /**\n     * Returns a partial copy of an object omitting the keys specified.\n     *\n     * @func\n     * @memberOf R\n     * @category Object\n     * @sig [String] -> {String: *} -> {String: *}\n     * @param {Array} names an array of String property names to omit from the new object\n     * @param {Object} obj The object to copy from\n     * @return {Object} A new object with properties from `names` not on it.\n     * @see R.pick\n     * @example\n     *\n     *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n     */\n    var omit = _curry2(function omit(names, obj) {\n        var result = {};\n        for (var prop in obj) {\n            if (!_contains(prop, names)) {\n                result[prop] = obj[prop];\n            }\n        }\n        return result;\n    });\n\n    /**\n     * Returns the left-to-right Kleisli composition of the provided functions,\n     * each of which must return a value of a type supported by [`chain`](#chain).\n     *\n     * `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @see R.composeK\n     * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)\n     * @param {...Function}\n     * @return {Function}\n     * @example\n     *\n     *      //  parseJson :: String -> Maybe *\n     *      //  get :: String -> Object -> Maybe *\n     *\n     *      //  getStateCode :: Maybe String -> Maybe String\n     *      var getStateCode = R.pipeK(\n     *        parseJson,\n     *        get('user'),\n     *        get('address'),\n     *        get('state'),\n     *        R.compose(Maybe.of, R.toUpper)\n     *      );\n     *\n     *      getStateCode(Maybe.of('{\"user\":{\"address\":{\"state\":\"ny\"}}}'));\n     *      //=> Just('NY')\n     *      getStateCode(Maybe.of('[Invalid JSON]'));\n     *      //=> Nothing()\n     */\n    var pipeK = function pipeK() {\n        return composeK.apply(this, reverse(arguments));\n    };\n\n    /**\n     * Returns the string representation of the given value. `eval`'ing the output\n     * should result in a value equivalent to the input value. Many of the built-in\n     * `toString` methods do not satisfy this requirement.\n     *\n     * If the given value is an `[object Object]` with a `toString` method other\n     * than `Object.prototype.toString`, this method is invoked with no arguments\n     * to produce the return value. This means user-defined constructor functions\n     * can provide a suitable `toString` method. For example:\n     *\n     *     function Point(x, y) {\n     *       this.x = x;\n     *       this.y = y;\n     *     }\n     *\n     *     Point.prototype.toString = function() {\n     *       return 'new Point(' + this.x + ', ' + this.y + ')';\n     *     };\n     *\n     *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig * -> String\n     * @param {*} val\n     * @return {String}\n     * @example\n     *\n     *      R.toString(42); //=> '42'\n     *      R.toString('abc'); //=> '\"abc\"'\n     *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n     *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n     *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n     */\n    var toString = _curry1(function toString(val) {\n        return _toString(val, []);\n    });\n\n    /**\n     * Combines two lists into a set (i.e. no duplicates) composed of the\n     * elements of each list.\n     *\n     * @func\n     * @memberOf R\n     * @category Relation\n     * @sig [a] -> [a] -> [a]\n     * @param {Array} as The first list.\n     * @param {Array} bs The second list.\n     * @return {Array} The first and second lists concatenated, with\n     *         duplicates removed.\n     * @example\n     *\n     *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n     */\n    var union = _curry2(compose(uniq, _concat));\n\n    /**\n     * Returns a new list containing only one copy of each element in the\n     * original list, based upon the value returned by applying the supplied\n     * function to each list element. Prefers the first item if the supplied\n     * function produces the same value on two items. `R.equals` is used for\n     * comparison.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig (a -> b) -> [a] -> [a]\n     * @param {Function} fn A function used to produce a value to use during comparisons.\n     * @param {Array} list The array to consider.\n     * @return {Array} The list of unique items.\n     * @example\n     *\n     *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n     */\n    var uniqBy = _curry2(function uniqBy(fn, list) {\n        var idx = 0, applied = [], result = [], appliedItem, item;\n        while (idx < list.length) {\n            item = list[idx];\n            appliedItem = fn(item);\n            if (!_contains(appliedItem, applied)) {\n                result.push(item);\n                applied.push(appliedItem);\n            }\n            idx += 1;\n        }\n        return result;\n    });\n\n    /**\n     * Turns a named method with a specified arity into a function\n     * that can be called directly supplied with arguments and a target object.\n     *\n     * The returned function is curried and accepts `arity + 1` parameters where\n     * the final parameter is the target object.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n     * @param {Number} arity Number of arguments the returned function should take\n     *        before the target object.\n     * @param {Function} method Name of the method to call.\n     * @return {Function} A new curried function.\n     * @example\n     *\n     *      var sliceFrom = R.invoker(1, 'slice');\n     *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n     *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n     *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n     */\n    var invoker = _curry2(function invoker(arity, method) {\n        return curryN(arity + 1, function () {\n            var target = arguments[arity];\n            if (target != null && is(Function, target[method])) {\n                return target[method].apply(target, _slice(arguments, 0, arity));\n            }\n            throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n        });\n    });\n\n    /**\n     * Returns a string made by inserting the `separator` between each\n     * element and concatenating all the elements into a single string.\n     *\n     * @func\n     * @memberOf R\n     * @category List\n     * @sig String -> [a] -> String\n     * @param {Number|String} separator The string used to separate the elements.\n     * @param {Array} xs The elements to join into a string.\n     * @return {String} str The string made by concatenating `xs` with `separator`.\n     * @see R.split\n     * @example\n     *\n     *      var spacer = R.join(' ');\n     *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n     *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n     */\n    var join = invoker(1, 'join');\n\n    /**\n     * Creates a new function that, when invoked, caches the result of calling `fn` for a given\n     * argument set and returns the result. Subsequent calls to the memoized `fn` with the same\n     * argument set will not result in an additional call to `fn`; instead, the cached result\n     * for that set of arguments will be returned.\n     *\n     * @func\n     * @memberOf R\n     * @category Function\n     * @sig (*... -> a) -> (*... -> a)\n     * @param {Function} fn The function to memoize.\n     * @return {Function} Memoized version of `fn`.\n     * @example\n     *\n     *      var count = 0;\n     *      var factorial = R.memoize(function(n) {\n     *        count += 1;\n     *        return R.product(R.range(1, n + 1));\n     *      });\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      factorial(5); //=> 120\n     *      count; //=> 1\n     */\n    var memoize = _curry1(function memoize(fn) {\n        var cache = {};\n        return function () {\n            var key = toString(arguments);\n            if (!_has(key, cache)) {\n                cache[key] = fn.apply(this, arguments);\n            }\n            return cache[key];\n        };\n    });\n\n    /**\n     * Splits a string into an array of strings based on the given\n     * separator.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String -> [String]\n     * @param {String} sep The separator string.\n     * @param {String} str The string to separate into an array.\n     * @return {Array} The array of strings from `str` separated by `str`.\n     * @see R.join\n     * @example\n     *\n     *      var pathComponents = R.split('/');\n     *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n     *\n     *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n     */\n    var split = invoker(1, 'split');\n\n    /**\n     * The lower case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to lower case.\n     * @return {String} The lower case version of `str`.\n     * @see R.toUpper\n     * @example\n     *\n     *      R.toLower('XYZ'); //=> 'xyz'\n     */\n    var toLower = invoker(0, 'toLowerCase');\n\n    /**\n     * The upper case version of a string.\n     *\n     * @func\n     * @memberOf R\n     * @category String\n     * @sig String -> String\n     * @param {String} str The string to upper case.\n     * @return {String} The upper case version of `str`.\n     * @see R.toLower\n     * @example\n     *\n     *      R.toUpper('abc'); //=> 'ABC'\n     */\n    var toUpper = invoker(0, 'toUpperCase');\n\n    var R = {\n        F: F,\n        T: T,\n        __: __,\n        add: add,\n        addIndex: addIndex,\n        adjust: adjust,\n        all: all,\n        allPass: allPass,\n        always: always,\n        and: and,\n        any: any,\n        anyPass: anyPass,\n        ap: ap,\n        aperture: aperture,\n        append: append,\n        apply: apply,\n        assoc: assoc,\n        assocPath: assocPath,\n        binary: binary,\n        bind: bind,\n        both: both,\n        call: call,\n        chain: chain,\n        clone: clone,\n        commute: commute,\n        commuteMap: commuteMap,\n        comparator: comparator,\n        complement: complement,\n        compose: compose,\n        composeK: composeK,\n        composeP: composeP,\n        concat: concat,\n        cond: cond,\n        construct: construct,\n        constructN: constructN,\n        contains: contains,\n        containsWith: containsWith,\n        converge: converge,\n        countBy: countBy,\n        createMapEntry: createMapEntry,\n        curry: curry,\n        curryN: curryN,\n        dec: dec,\n        defaultTo: defaultTo,\n        difference: difference,\n        differenceWith: differenceWith,\n        dissoc: dissoc,\n        dissocPath: dissocPath,\n        divide: divide,\n        drop: drop,\n        dropLast: dropLast,\n        dropLastWhile: dropLastWhile,\n        dropRepeats: dropRepeats,\n        dropRepeatsWith: dropRepeatsWith,\n        dropWhile: dropWhile,\n        either: either,\n        empty: empty,\n        eqProps: eqProps,\n        equals: equals,\n        evolve: evolve,\n        filter: filter,\n        find: find,\n        findIndex: findIndex,\n        findLast: findLast,\n        findLastIndex: findLastIndex,\n        flatten: flatten,\n        flip: flip,\n        forEach: forEach,\n        fromPairs: fromPairs,\n        functions: functions,\n        functionsIn: functionsIn,\n        groupBy: groupBy,\n        gt: gt,\n        gte: gte,\n        has: has,\n        hasIn: hasIn,\n        head: head,\n        identical: identical,\n        identity: identity,\n        ifElse: ifElse,\n        inc: inc,\n        indexOf: indexOf,\n        init: init,\n        insert: insert,\n        insertAll: insertAll,\n        intersection: intersection,\n        intersectionWith: intersectionWith,\n        intersperse: intersperse,\n        into: into,\n        invert: invert,\n        invertObj: invertObj,\n        invoker: invoker,\n        is: is,\n        isArrayLike: isArrayLike,\n        isEmpty: isEmpty,\n        isNil: isNil,\n        isSet: isSet,\n        join: join,\n        keys: keys,\n        keysIn: keysIn,\n        last: last,\n        lastIndexOf: lastIndexOf,\n        length: length,\n        lens: lens,\n        lensIndex: lensIndex,\n        lensProp: lensProp,\n        lift: lift,\n        liftN: liftN,\n        lt: lt,\n        lte: lte,\n        map: map,\n        mapAccum: mapAccum,\n        mapAccumRight: mapAccumRight,\n        mapObj: mapObj,\n        mapObjIndexed: mapObjIndexed,\n        match: match,\n        mathMod: mathMod,\n        max: max,\n        maxBy: maxBy,\n        mean: mean,\n        median: median,\n        memoize: memoize,\n        merge: merge,\n        mergeAll: mergeAll,\n        min: min,\n        minBy: minBy,\n        modulo: modulo,\n        multiply: multiply,\n        nAry: nAry,\n        negate: negate,\n        none: none,\n        not: not,\n        nth: nth,\n        nthArg: nthArg,\n        nthChar: nthChar,\n        nthCharCode: nthCharCode,\n        of: of,\n        omit: omit,\n        once: once,\n        or: or,\n        over: over,\n        partial: partial,\n        partialRight: partialRight,\n        partition: partition,\n        path: path,\n        pathEq: pathEq,\n        pick: pick,\n        pickAll: pickAll,\n        pickBy: pickBy,\n        pipe: pipe,\n        pipeK: pipeK,\n        pipeP: pipeP,\n        pluck: pluck,\n        prepend: prepend,\n        product: product,\n        project: project,\n        prop: prop,\n        propEq: propEq,\n        propIs: propIs,\n        propOr: propOr,\n        propSatisfies: propSatisfies,\n        props: props,\n        range: range,\n        reduce: reduce,\n        reduceRight: reduceRight,\n        reduced: reduced,\n        reject: reject,\n        remove: remove,\n        repeat: repeat,\n        replace: replace,\n        reverse: reverse,\n        scan: scan,\n        set: set,\n        slice: slice,\n        sort: sort,\n        sortBy: sortBy,\n        split: split,\n        splitEvery: splitEvery,\n        subtract: subtract,\n        sum: sum,\n        tail: tail,\n        take: take,\n        takeLast: takeLast,\n        takeLastWhile: takeLastWhile,\n        takeWhile: takeWhile,\n        tap: tap,\n        test: test,\n        times: times,\n        toLower: toLower,\n        toPairs: toPairs,\n        toPairsIn: toPairsIn,\n        toString: toString,\n        toUpper: toUpper,\n        transduce: transduce,\n        trim: trim,\n        type: type,\n        unapply: unapply,\n        unary: unary,\n        uncurryN: uncurryN,\n        unfold: unfold,\n        union: union,\n        unionWith: unionWith,\n        uniq: uniq,\n        uniqBy: uniqBy,\n        uniqWith: uniqWith,\n        unnest: unnest,\n        update: update,\n        useWith: useWith,\n        values: values,\n        valuesIn: valuesIn,\n        view: view,\n        where: where,\n        whereEq: whereEq,\n        wrap: wrap,\n        xprod: xprod,\n        zip: zip,\n        zipObj: zipObj,\n        zipWith: zipWith\n    };\n\n  /* TEST_ENTRY_POINT */\n\n  if (typeof exports === 'object') {\n    module.exports = R;\n  } else if (typeof define === 'function' && define.amd) {\n    define(function() { return R; });\n  } else {\n    this.R = R;\n  }\n\n}.call(this));\n","var always = require('./always');\n\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig * -> true\n * @return {Boolean} `true`.\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments,\n * regardless of their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n/**\n * Applies a function to the value at the given index of an array,\n * returning a new copy of the array with the element at the given\n * index replaced with the result of the function application.\n * @see R.update\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @example\n *\n *      R.adjust(R.add(10), 1, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.adjust(R.add(10))(1)([0, 1, 2]);     //=> [0, 11, 2]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator)\n * in other languages and libraries.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new list containing the contents of the given list, followed by the given\n * element.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list whose contents will be added to the beginning of the output\n *        list.\n * @return {Array} A new list containing the contents of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value.  Note that this copies and flattens\n * prototype properties onto the new object as well.  All non-primitive\n * properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop the property name to set\n * @param {*} val the new value\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original except for the specified property.\n * @see R.dissoc\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @category Function\n * @category Object\n * @see R.partial\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions must be unary.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      var f = R.compose(R.inc, R.negate, Math.pow);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns `true` if the specified value is equal, in `R.equals` terms,\n * to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the item is in the list, `false` otherwise.\n *\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains([42], [[42]]); //=> true\n */\nmodule.exports = _curry2(_contains);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function. The curried\n * function has two unusual capabilities. First, its arguments needn't\n * be provided one at a time. If `f` is a ternary function and `g` is\n * `R.curry(f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN\n * @example\n *\n *      var addFourNumbers = function(a, b, c, d) {\n *        return a + b + c + d;\n *      };\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop the name of the property to dissociate\n * @param {Object} obj the object to clone\n * @return {Object} a new object similar to the original but without the specified property\n * @see R.assoc\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    if (p !== prop) {\n      result[p] = obj[p];\n    }\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\nvar _hasMethod = require('./internal/_hasMethod');\n\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise.\n * Dispatches to an `equals` method if present. Handles cyclical data\n * structures.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _hasMethod('equals', a) ? a.equals(b) :\n         _hasMethod('equals', b) ? b.equals(a) : _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`, according to the\n * `transformation` functions. All non-primitive properties are copied by reference.\n *\n * A `tranformation` function will not be invoked if its corresponding key does not exist in\n * the evolved object.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var transformation, key, type, result = {};\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key])\n                : type === 'object'   ? evolve(transformations[key], object[key])\n                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _xfilter = require('./internal/_xfilter');\n\n\n/**\n * Returns a new list containing only those items that match a given predicate function.\n * The predicate function is passed one argument: *(value)*.\n *\n * Note that `R.filter` does not skip deleted or unassigned indices, unlike the native\n * `Array.prototype.filter` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.reject\n * @example\n *\n *      var isEven = function(n) {\n *        return n % 2 === 0;\n *      };\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, _filter));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\n","module.exports = function _arity(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","var _isArray = require('./_isArray');\nvar _slice = require('./_slice');\n\n\n/**\n * Similar to hasMethod, this checks whether a function has a [methodname]\n * function. If it isn't an array it will execute that function otherwise it will\n * default to the ramda implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, _slice(arguments, 0, length - 1));\n  };\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f2;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 1) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f2;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b); });\n    } else {\n      return fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    var n = arguments.length;\n    if (n === 0) {\n      return f3;\n    } else if (n === 1 && a != null && a['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 1) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 2 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 2 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 2) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return f3;\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          b != null && b['@@functional/placeholder'] === true) {\n      return _curry2(function(a, b) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(a, c) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true &&\n                          c != null && c['@@functional/placeholder'] === true) {\n      return _curry2(function(b, c) { return fn(a, b, c); });\n    } else if (n === 3 && a != null && a['@@functional/placeholder'] === true) {\n      return _curry1(function(a) { return fn(a, b, c); });\n    } else if (n === 3 && b != null && b['@@functional/placeholder'] === true) {\n      return _curry1(function(b) { return fn(a, b, c); });\n    } else if (n === 3 && c != null && c['@@functional/placeholder'] === true) {\n      return _curry1(function(c) { return fn(a, b, c); });\n    } else {\n      return fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a  function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n// The algorithm used to handle cyclic structures is\n// inspired by underscore's isEqual\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  var typeA = type(a);\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeA === 'Boolean' || typeA === 'Number' || typeA === 'String') {\n    return typeof a === 'object' ?\n      typeof b === 'object' && identical(a.valueOf(), b.valueOf()) :\n      identical(a, b);\n  }\n\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (typeA === 'RegExp') {\n    // RegExp equality algorithm: http://stackoverflow.com/a/10776635\n    return (a.source === b.source) &&\n           (a.global === b.global) &&\n           (a.ignoreCase === b.ignoreCase) &&\n           (a.multiline === b.multiline) &&\n           (a.sticky === b.sticky) &&\n           (a.unicode === b.unicode);\n  }\n\n  if (Object(a) === a) {\n    if (typeA === 'Date' && a.getTime() !== b.getTime()) {\n      return false;\n    }\n\n    var keysA = keys(a);\n    if (keysA.length !== keys(b).length) {\n      return false;\n    }\n\n    var idx = stackA.length - 1;\n    while (idx >= 0) {\n      if (stackA[idx] === a) {\n        return stackB[idx] === b;\n      }\n      idx -= 1;\n    }\n\n    stackA[stackA.length] = a;\n    stackB[stackB.length] = b;\n    idx = keysA.length - 1;\n    while (idx >= 0) {\n      var key = keysA[idx];\n      if (!_has(key, b) || !_equals(b[key], a[key], stackA, stackB)) {\n        return false;\n      }\n      idx -= 1;\n    }\n    stackA.pop();\n    stackB.pop();\n    return true;\n  }\n  return false;\n};\n","module.exports = function _filter(fn, list) {\n  var idx = 0, len = list.length, result = [];\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","var _isArray = require('./_isArray');\n\n\n/**\n * Private function that determines whether or not a provided object has a given method.\n * Does not ignore methods stored on the object's prototype chain. Used for dynamically\n * dispatching Ramda methods to non-Array objects.\n *\n * @private\n * @param {String} methodName The name of the method to check for.\n * @param {Object} obj The object to test.\n * @return {Boolean} `true` has a given method, `false` otherwise.\n * @example\n *\n *      var person = { name: 'John' };\n *      person.shout = function() { alert(this.name); };\n *\n *      _hasMethod('shout', person); //=> true\n *      _hasMethod('foo', person); //=> false\n */\nmodule.exports = function _hasMethod(methodName, obj) {\n  return obj != null && !_isArray(obj) && typeof obj[methodName] === 'function';\n};\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, item, from) {\n  var idx = from;\n  while (idx < list.length) {\n    if (equals(list[idx], item)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","module.exports = function _map(fn, list) {\n  var idx = 0, len = list.length, result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(list[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = function _quote(s) {\n  return '\"' + s.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0, len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n})();\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\nvar test = require('../test');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(test(/^\\d+$/), keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + _quote(_toISOString(x)) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      return (typeof x.constructor === 'function' && x.constructor.name !== 'Object' &&\n              typeof x.toString === 'function' && x.toString() !== '[object Object]') ?\n             x.toString() :  // Function, RegExp, user-defined types\n             '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n})();\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n})();\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\nvar is = require('./is');\nvar toString = require('./toString');\n\n\n/**\n * Turns a named method with a specified arity into a function\n * that can be called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {Function} method Name of the method to call.\n * @return {Function} A new curried function.\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && is(Function, target[method])) {\n      return target[method].apply(target, _slice(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * See if an object (`val`) is an instance of the supplied constructor.\n * This function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (x instanceof String) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Returns a list containing the names of all the enumerable own\n * properties of the supplied object.\n * Note that the order of the output array is not guaranteed to be\n * consistent across different JS platforms.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, ks = [], nIdx;\n      for (prop in obj) {\n        if (_has(prop, obj)) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _xmap = require('./internal/_xmap');\n\n\n/**\n * Returns a new list, constructed by applying the supplied function to every element of the\n * supplied list.\n *\n * Note: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\n * native `Array.prototype.map` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> b) -> [a] -> [b]\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @example\n *\n *      var double = function(x) {\n *        return x * 2;\n *      };\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, _map));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\n/**\n * Create a new object with the own properties of `a`\n * merged with the own properties of object `b`.\n *\n * @func\n * @memberOf R\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} a\n * @param {Object} b\n * @return {Object}\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n */\nmodule.exports = _curry2(function merge(a, b) {\n  var result = {};\n  var ks = keys(a);\n  var idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = a[ks[idx]];\n    idx += 1;\n  }\n  ks = keys(b);\n  idx = 0;\n  while (idx < ks.length) {\n    result[ks[idx]] = b[ks[idx]];\n    idx += 1;\n  }\n  return result;\n});\n","var _pipe = require('./internal/_pipe');\nvar curryN = require('./curryN');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return curryN(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling the iterator\n * function and passing it an accumulator value and the current value from the array, and\n * then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\n * shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\n * the native `Array.prototype.reduce` method. For more details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n * @see R.reduced\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a,b -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var add = function(a, b) {\n *        return a + b;\n *      };\n *\n *      R.reduce(add, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * Similar to `filter`, except that it keeps only values for which the given predicate\n * function returns falsy. The predicate function is passed one argument: *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n * @see R.transduce\n *\n * @func\n * @memberOf R\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} The new filtered array.\n * @see R.filter\n * @example\n *\n *      var isOdd = function(n) {\n *        return n % 2 === 1;\n *      };\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n */\nmodule.exports = _curry2(function reject(fn, list) {\n  return filter(_complement(fn), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\n\n\n/**\n * Returns a new list with the same elements as the original list, just\n * in the reverse order.\n *\n * @func\n * @memberOf R\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The list to reverse.\n * @return {Array} A copy of the list in reverse order.\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n */\nmodule.exports = _curry1(function reverse(list) {\n  return _slice(list).reverse();\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * @func\n * @memberOf R\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar slice = require('./slice');\n\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * @func\n * @memberOf R\n * @category List\n * @see R.head, R.init, R.last\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nmodule.exports = _checkForMethod('tail', slice(1, Infinity));\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @see R.match\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nmodule.exports = _curry2(function test(pattern, str) {\n  return _cloneRegExp(pattern).test(str);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var _curry1 = require('./internal/_curry1');\n\n\n/**\n * Gives a single-word string description of the (native) type of a value, returning such\n * answers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\n * Object types any further, reporting them all as 'Object'.\n *\n * @func\n * @memberOf R\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var VNode = require('./vnode');\nvar is = require('./is');\n\nmodule.exports = function h(sel, b, c) {\n  var data = {}, children, text, i;\n  if (arguments.length === 3) {\n    data = b;\n    if (is.array(c)) { children = c; }\n    else if (is.primitive(c)) { text = c; }\n  } else if (arguments.length === 2) {\n    if (is.array(b)) { children = b; }\n    else if (is.primitive(b)) { text = b; }\n    else { data = b; }\n  }\n  if (is.array(children)) {\n    for (i = 0; i < children.length; ++i) {\n      if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]);\n    }\n  }\n  return VNode(sel, data, children, text, undefined);\n};\n","module.exports = {\n  array: Array.isArray,\n  primitive: function(s) { return typeof s === 'string' || typeof s === 'number'; },\n};\n","var booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\", \n                \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\", \n                \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\", \n                \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\", \n                \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\", \n                \"truespeed\", \"typemustmatch\", \"visible\"];\n    \nvar booleanAttrsDict = {};\nfor(var i=0, len = booleanAttrs.length; i < len; i++) {\n  booleanAttrsDict[booleanAttrs[i]] = true;\n}\n    \nfunction updateAttrs(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldAttrs = oldVnode.data.attrs || {}, attrs = vnode.data.attrs || {};\n  \n  // update modified attributes, add new attributes\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      // TODO: add support to namespaced attributes (setAttributeNS)\n      if(!cur && booleanAttrsDict[key])\n        elm.removeAttribute(key);\n      else\n        elm.setAttribute(key, cur);\n    }\n  }\n  //remove removed attributes\n  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n  // the other option is to remove all attributes with value == undefined\n  for (key in oldAttrs) {\n    if (!(key in attrs)) {\n      elm.removeAttribute(key);\n    }\n  }\n}\n\nmodule.exports = {create: updateAttrs, update: updateAttrs};\n","function updateClass(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldClass = oldVnode.data.class || {},\n      klass = vnode.data.class || {};\n  for (name in klass) {\n    cur = klass[name];\n    if (cur !== oldClass[name]) {\n      elm.classList[cur ? 'add' : 'remove'](name);\n    }\n  }\n}\n\nmodule.exports = {create: updateClass, update: updateClass};\n","var is = require('../is');\n\nfunction arrInvoker(arr) {\n  return function() {\n    // Special case when length is two, for performance\n    arr.length === 2 ? arr[0](arr[1]) : arr[0].apply(undefined, arr.slice(1));\n  };\n}\n\nfunction fnInvoker(o) {\n  return function(ev) { o.fn(ev); };\n}\n\nfunction updateEventListeners(oldVnode, vnode) {\n  var name, cur, old, elm = vnode.elm,\n      oldOn = oldVnode.data.on || {}, on = vnode.data.on;\n  if (!on) return;\n  for (name in on) {\n    cur = on[name];\n    old = oldOn[name];\n    if (old === undefined) {\n      if (is.array(cur)) {\n        elm.addEventListener(name, arrInvoker(cur));\n      } else {\n        cur = {fn: cur};\n        on[name] = cur;\n        elm.addEventListener(name, fnInvoker(cur));\n      }\n    } else if (is.array(old)) {\n      // Deliberately modify old array since it's captured in closure created with `arrInvoker`\n      old.length = cur.length;\n      for (var i = 0; i < old.length; ++i) old[i] = cur[i];\n      on[name]  = old;\n    } else {\n      old.fn = cur;\n      on[name] = old;\n    }\n  }\n}\n\nmodule.exports = {create: updateEventListeners, update: updateEventListeners};\n","function updateProps(oldVnode, vnode) {\n  var key, cur, old, elm = vnode.elm,\n      oldProps = oldVnode.data.props || {}, props = vnode.data.props || {};\n  for (key in props) {\n    cur = props[key];\n    old = oldProps[key];\n    if (old !== cur) {\n      elm[key] = cur;\n    }\n  }\n}\n\nmodule.exports = {create: updateProps, update: updateProps};\n","var raf = requestAnimationFrame || setTimeout;\nvar nextFrame = function(fn) { raf(function() { raf(fn); }); };\n\nfunction setNextFrame(obj, prop, val) {\n  nextFrame(function() { obj[prop] = val; });\n}\n\nfunction updateStyle(oldVnode, vnode) {\n  var cur, name, elm = vnode.elm,\n      oldStyle = oldVnode.data.style || {},\n      style = vnode.data.style || {},\n      oldHasDel = 'delayed' in oldStyle;\n  for (name in style) {\n    cur = style[name];\n    if (name === 'delayed') {\n      for (name in style.delayed) {\n        cur = style.delayed[name];\n        if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n          setNextFrame(elm.style, name, cur);\n        }\n      }\n    } else if (name !== 'remove' && cur !== oldStyle[name]) {\n      elm.style[name] = cur;\n    }\n  }\n}\n\nfunction applyDestroyStyle(vnode) {\n  var style, name, elm = vnode.elm, s = vnode.data.style;\n  if (!s || !(style = s.destroy)) return;\n  for (name in style) {\n    elm.style[name] = style[name];\n  }\n}\n\nfunction applyRemoveStyle(vnode, rm) {\n  var s = vnode.data.style;\n  if (!s || !s.remove) {\n    rm();\n    return;\n  }\n  var name, elm = vnode.elm, idx, i = 0, maxDur = 0,\n      compStyle, style = s.remove, amount = 0, applied = [];\n  for (name in style) {\n    applied.push(name);\n    elm.style[name] = style[name];\n  }\n  compStyle = getComputedStyle(elm);\n  var props = compStyle['transition-property'].split(', ');\n  for (; i < props.length; ++i) {\n    if(applied.indexOf(props[i]) !== -1) amount++;\n  }\n  elm.addEventListener('transitionend', function(ev) {\n    if (ev.target === elm) --amount;\n    if (amount === 0) rm();\n  });\n}\n\nmodule.exports = {create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle};\n","// jshint newcap: false\n/* global require, module, document, Element */\n'use strict';\n\nvar VNode = require('./vnode');\nvar is = require('./is');\n\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\n\nfunction emptyNodeAt(elm) {\n  return VNode(elm.tagName, {}, [], undefined, elm);\n}\n\nvar emptyNode = VNode('', {}, [], undefined, undefined);\n\nvar insertedVnodeQueue;\n\nfunction sameVnode(vnode1, vnode2) {\n  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\n\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n  var i, map = {}, key;\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) map[key] = i;\n  }\n  return map;\n}\n\nfunction createRmCb(childElm, listeners) {\n  return function() {\n    if (--listeners === 0) childElm.parentElement.removeChild(childElm);\n  };\n}\n\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\n\nfunction init(modules) {\n  var i, j, cbs = {};\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]);\n    }\n  }\n\n  function createElm(vnode) {\n    var i, data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode);\n      if (isDef(i = data.vnode)) vnode = i;\n    }\n    var elm, children = vnode.children, sel = vnode.sel;\n    if (isDef(sel)) {\n      // Parse selector\n      var hashIdx = sel.indexOf('#');\n      var dotIdx = sel.indexOf('.', hashIdx);\n      var hash = hashIdx > 0 ? hashIdx : sel.length;\n      var dot = dotIdx > 0 ? dotIdx : sel.length;\n      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n      elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag)\n                                                          : document.createElement(tag);\n      if (hash < dot) elm.id = sel.slice(hash + 1, dot);\n      if (dotIdx > 0) elm.className = sel.slice(dot+1).replace(/\\./g, ' ');\n      if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n          elm.appendChild(createElm(children[i]));\n        }\n      } else if (is.primitive(vnode.text)) {\n        elm.appendChild(document.createTextNode(vnode.text));\n      }\n      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);\n      i = vnode.data.hook; // Reuse variable\n      if (isDef(i)) {\n        if (i.create) i.create(emptyNode, vnode);\n        if (i.insert) insertedVnodeQueue.push(vnode);\n      }\n    } else {\n      elm = vnode.elm = document.createTextNode(vnode.text);\n    }\n    return vnode.elm;\n  }\n\n  function addVnodes(parentElm, before, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      parentElm.insertBefore(createElm(vnodes[startIdx]), before);\n    }\n  }\n\n  function invokeDestroyHook(vnode) {\n    var i = vnode.data, j;\n    if (isDef(i)) {\n      if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode);\n      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);\n      if (isDef(i = vnode.children)) {\n        for (j = 0; j < vnode.children.length; ++j) {\n          invokeDestroyHook(vnode.children[j]);\n        }\n      }\n    }\n  }\n\n  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var i, listeners, rm, ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.sel)) {\n          invokeDestroyHook(ch);\n          listeners = cbs.remove.length + 1;\n          rm = createRmCb(ch.elm, listeners);\n          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);\n          if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) {\n            i(ch, rm);\n          } else {\n            rm();\n          }\n        } else { // Text node\n          parentElm.removeChild(ch.elm);\n        }\n      }\n    }\n  }\n\n  function updateChildren(parentElm, oldCh, newCh) {\n    var oldStartIdx = 0, newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, elmToMove, before;\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode);\n        parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode);\n        parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n        idxInOld = oldKeyToIdx[newStartVnode.key];\n        if (isUndef(idxInOld)) { // New element\n          parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        } else {\n          elmToMove = oldCh[idxInOld];\n          patchVnode(elmToMove, newStartVnode);\n          oldCh[idxInOld] = undefined;\n          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm);\n          newStartVnode = newCh[++newStartIdx];\n        }\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      before = isUndef(newCh[newEndIdx+1]) ? null : newCh[newEndIdx+1].elm;\n      addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function patchVnode(oldVnode, vnode) {\n    var i, hook;\n    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n      i(oldVnode, vnode);\n    }\n    if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i;\n    if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i;\n    var elm = vnode.elm = oldVnode.elm, oldCh = oldVnode.children, ch = vnode.children;\n    if (oldVnode === vnode) return;\n    if (isDef(vnode.data)) {\n      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);\n      i = vnode.data.hook;\n      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) updateChildren(elm, oldCh, ch);\n      } else if (isDef(ch)) {\n        addVnodes(elm, null, ch, 0, ch.length - 1);\n      } else if (isDef(oldCh)) {\n        removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      elm.textContent = vnode.text;\n    }\n    if (isDef(hook) && isDef(i = hook.postpatch)) {\n      i(oldVnode, vnode);\n    }\n    return vnode;\n  }\n\n  return function(oldVnode, vnode) {\n    var i;\n    insertedVnodeQueue = [];\n    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();\n    if (oldVnode instanceof Element) {\n      if (oldVnode.parentElement !== null) {\n        createElm(vnode);\n        oldVnode.parentElement.replaceChild(vnode.elm, oldVnode);\n      } else {\n        oldVnode = emptyNodeAt(oldVnode);\n        patchVnode(oldVnode, vnode);\n      }\n    } else {\n      patchVnode(oldVnode, vnode);\n    }\n    for (i = 0; i < insertedVnodeQueue.length; ++i) {\n      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n    }\n    insertedVnodeQueue = undefined;\n    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();\n    return vnode;\n  };\n}\n\nmodule.exports = {init: init};\n","module.exports = function(sel, data, children, text, elm) {\n  var key = data === undefined ? undefined : data.key;\n  return {sel: sel, data: data, children: children,\n          text: text, elm: elm, key: key};\n};\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\n * parameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\n * functions produced by `arity` will pass all provided arguments to the wrapped function.\n *\n * @func\n * @memberOf R\n * @sig (Number, (* -> *)) -> (* -> *)\n * @category Function\n * @param {Number} n The desired arity of the returned function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is\n *         guaranteed to be of arity `n`.\n * @deprecated since v0.15.0\n * @example\n *\n *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var takesOneArg = R.arity(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // All arguments are passed through to the wrapped function\n *      takesOneArg(1, 2); //=> [1, 2]\n */\nmodule.exports = _curry2(function(n, fn) {\n  // jshint unused:vars\n  switch (n) {\n    case 0: return function() {return fn.apply(this, arguments);};\n    case 1: return function(a0) {return fn.apply(this, arguments);};\n    case 2: return function(a0, a1) {return fn.apply(this, arguments);};\n    case 3: return function(a0, a1, a2) {return fn.apply(this, arguments);};\n    case 4: return function(a0, a1, a2, a3) {return fn.apply(this, arguments);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.apply(this, arguments);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.apply(this, arguments);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.apply(this, arguments);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.apply(this, arguments);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.apply(this, arguments);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.apply(this, arguments);};\n    default: throw new Error('First argument to arity must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\nvar arity = require('./arity');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the\n * specified arity. The curried function has two unusual capabilities.\n * First, its arguments needn't be provided one at a time. If `g` is\n * `R.curryN(3, f)`, the following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`,\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var addFourNumbers = function() {\n *        return R.sum([].slice.call(arguments, 0, 4));\n *      };\n *\n *      var curriedAddFourNumbers = R.curryN(4, addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  return arity(length, _curryN(length, [], fn));\n});\n","/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0) {\n      return f1;\n    } else if (a != null && a['@@functional/placeholder'] === true) {\n      return f1;\n    } else {\n      return fn(a);\n    }\n  };\n};\n","var arity = require('../arity');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @return {array} An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (received[combinedIdx] == null ||\n           received[combinedIdx]['@@functional/placeholder'] !== true ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (result == null || result['@@functional/placeholder'] !== true) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : arity(left, _curryN(length, combined, fn));\n  };\n};\n","var curryN = require('ramda/src/curryN');\n\nfunction isString(s) { return typeof s === 'string'; }\nfunction isNumber(n) { return typeof n === 'number'; }\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\nfunction isFunction(f) { return typeof f === 'function'; }\nvar isArray = Array.isArray || function(a) { return 'length' in a; };\n\nvar mapConstrToFn = curryN(2, function(group, constr) {\n  return constr === String    ? isString\n       : constr === Number    ? isNumber\n       : constr === Object    ? isObject\n       : constr === Array     ? isArray\n       : constr === Function  ? isFunction\n       : constr === undefined ? group\n                              : constr;\n});\n\nfunction Constructor(group, name, validators) {\n  validators = validators.map(mapConstrToFn(group));\n  var constructor = curryN(validators.length, function() {\n    var val = [], v, validator;\n    for (var i = 0; i < arguments.length; ++i) {\n      v = arguments[i];\n      validator = validators[i];\n      if ((typeof validator === 'function' && validator(v)) ||\n          (v !== undefined && v !== null && v.of === validator)) {\n        val[i] = arguments[i];\n      } else {\n        throw new TypeError('wrong value ' + v + ' passed to location ' + i + ' in ' + name);\n      }\n    }\n    val.of = group;\n    val.name = name;\n    return val;\n  });\n  return constructor;\n}\n\nfunction rawCase(type, cases, action, arg) {\n  if (type !== action.of) throw new TypeError('wrong type passed to case');\n  var name = action.name in cases ? action.name\n           : '_' in cases         ? '_'\n                                  : undefined;\n  if (name === undefined) {\n    throw new Error('unhandled value passed to case');\n  } else {\n    return cases[name].apply(undefined, arg !== undefined ? action.concat([arg]) : action);\n  }\n}\n\nvar typeCase = curryN(3, rawCase);\nvar caseOn = curryN(4, rawCase);\n\nfunction Type(desc) {\n  var obj = {};\n  for (var key in desc) {\n    obj[key] = Constructor(obj, key, desc[key]);\n  }\n  obj.case = typeCase(obj);\n  obj.caseOn = caseOn(obj);\n  return obj;\n}\n\nmodule.exports = Type;\n"]} diff --git a/examples/file-uploader/js/list.js b/examples/file-uploader/js/list.js index 3c72af3..25f0816 100644 --- a/examples/file-uploader/js/list.js +++ b/examples/file-uploader/js/list.js @@ -59,24 +59,16 @@ const nextIndex = (model) => model.length; // view -const view = (model) => { - - return ( - h('ul', {style: style.ul}, model.map( listItemView ) ) - ); - -}; - -const listItemView = (item, i) => { - return ( - h('li', {style: style.li}, [ - upload.view( - { progress: { height: 20, width: 200 } }, - item - ) - ]) - ); -} +const view = (model) => h('ul', {style: style.ul}, model.map( listItemView )) + +const listItemView = (item, i) => ( + h('li', {style: style.li}, [ + upload.view( + { progress: { height: 20, width: 200 } }, + item + ) + ]) +) const style = { diff --git a/examples/file-uploader/js/upload.js b/examples/file-uploader/js/upload.js index 5154db0..9f3950f 100644 --- a/examples/file-uploader/js/upload.js +++ b/examples/file-uploader/js/upload.js @@ -17,8 +17,8 @@ const noop = function(){}; // model -const init = (files) => { - return { +const init = (files) => ( + { status: 'initial', progress: {}, abort: noop, @@ -27,47 +27,28 @@ const init = (files) => { : '(' + files.length + ' files)' ), files: map(initFile, files) } -} +) -const initFile = ({name,lastModifiedDate,size,type}) => { - return {name,lastModifiedDate,size,type} -} +const initFile = ({name,lastModifiedDate,size,type}) => ( + {name,lastModifiedDate,size,type} +) -const statusLabel = (model) => { - return { - 'initial': null, - 'uploading': 'uploading', - 'processing': 'processing', - 'uploaded': 'done', - 'error': 'error', - 'abort': 'stopped' - }[model.status] || null ; -} - -const actionLabel = (action) => { - return { - 'abort': '×' - }[action] || null ; -} - -const size = (model) => { - return reduce( (tot,file) => tot + (file.size || 0), 0, model.files ); -} +const size = (model) => ( + reduce( (tot,file) => tot + (file.size || 0), 0, model.files ) +) const status = curry( (s, model) => model.status == s ); const uploading = status('uploading'); -const aborted = (model) => { - return model.status == 'aborted'; -} +const aborted = (model) => model.status == 'aborted' -const abortable = (model) => { - return !!model.abort && contains(model.status, ['uploading']); -} +const abortable = (model) => ( + !!model.abort && contains(model.status, ['uploading']) +) -const hasProgressData = (x) => { - return !(x.loaded === undefined || x.total === undefined); -} +const hasProgressData = (x) => ( + !(x.loaded === undefined || x.total === undefined) +) const percentProgress = (p) => { if (!hasProgressData(p)) return null; @@ -120,17 +101,15 @@ const view = curry( ({progress},model) => { }); -const renderTitle = (model) => { - return ( - model.url - ? h('a', { attrs: {'href': model.url, - 'target': '_blank' - } - }, [ model.title ]) +const renderTitle = (model) => ( + model.url + ? h('a', { attrs: {'href': model.url, + 'target': '_blank' + } + }, [ model.title ]) - : h('span', {}, [ model.title ]) - ); -} + : h('span', {}, [ model.title ]) +) const renderProgress = (model,specs) => { @@ -158,18 +137,33 @@ const renderProgress = (model,specs) => { } -const renderStatus = (model) => { - return h('span', {}, statusLabel(model)); -} +const renderStatus = (model) => h('span', {}, statusLabel(model)) -const renderAbort = (model) => { - const label = actionLabel('abort'); - return h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}), - on: { click: model.abort } }, - label - ); -} +const renderAbort = (model) => ( + h('a', { style: merge(visible(abortable, model), {cursor: 'pointer'}), + on: { click: model.abort } }, + actionLabel('abort') + ) +) + + +const statusLabel = (model) => ( + { + 'initial': null, + 'uploading': 'uploading', + 'processing': 'processing', + 'uploaded': 'done', + 'error': 'error', + 'abort': 'stopped' + }[model.status] || null +) + +const actionLabel = (action) => ( + { + 'abort': '×' + }[action] || null +) // view styles @@ -185,9 +179,9 @@ const style = { // view utils -function visible(pred,model){ - return { display: pred(model) ? null : 'none' } -} +const visible = (pred,model) => ( + { display: pred(model) ? null : 'none' } +) module.exports = {init, Action, update, view};