{"version":3,"sources":["webpack:///./node_modules/@progress/kendo-ui/js/spreadsheet/runtime.functions.2.js","webpack:///./node_modules/@progress/kendo-ui/js/spreadsheet/runtime.js","webpack:///./node_modules/@progress/kendo-ui/js/spreadsheet/runtime.functions.js"],"names":["module","exports","modules","installedModules","__webpack_require__","moduleId","id","loaded","call","m","c","p","0","3","Error","1628","1672","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","f","define","apply","undefined","spreadsheet","kendo","calc","runtime","defineFunction","CalcError","packDate","unpackDate","isLeapYear","daysInMonth","_days_360","ll","ul","ERF","args","ERFC","GAMMALN","GAMMA","GAMMA_DIST","GAMMA_INV","NORM_S_DIST","NORM_S_INV","NORM_DIST","NORM_INV","BETADIST","BETA_DIST","BETA_INV","chisq_left","chisq_right","chisq_left_inv","chisq_right_inv","ac","ex","chisq_test","data","expon","poisson","Fdist","Fdist_right","Finv","Finv_right","Ftest","fisher","fisherinv","Tdist","Tdist_right","Tdist_2tail","Tdist_inv","Tdist_2tail_inv","Tdist_test","confidence_t","confidence_norm","gauss","phi","lognorm_dist","lognorm_inv","prob","slope","intercept","pearson","rsq","steyx","forecast","linest","logest","trend","growth","FV","PV","PMT","NPER","RATE","IPMT","PPMT","CUMPRINC","CUMIPMT","NPV","IRR","EFFECT","NOMINAL","XNPV","XIRR","ISPMT","DB","DDB","SLN","SYD","VDB","COUPS_ARGS","COUPDAYBS","COUPDAYS","COUPDAYSNC","COUPPCD","COUPNCD","COUPNUM","ACCRINTM","ACCRINT","DISC","INTRATE","RECEIVED","PRICE","PRICEDISC","MAX_IT","EPS","FP_MIN","f_abs","Math","abs","x","S","an","n","sqrt","PI","exp","s","frac","cof","y","tmp","ser","log","j","pi","sin","BETALN","a","b","BETA","gamma_inc","g_series","g_contfrac","sum","ap","gln","d","aj","bj","i","delta","cumulative","pow","Infinity","M","ab","q","r","plow","phigh","betastd_pdf","betastd_cdf","k","beta_lentz","m2","aa","del","h","qab","qam","qap","betastd_inv","cdf","cds","obsv","expect","rows","length","cols","eij","lnf","u","_mean","arr","me","_var_sq","v","arr1","arr2","n1","n2","va1","va2","e2","min","gr1","gr2","tail","type","t_st","df","d2","md","m1","v1","v2","u1","u2","q1","q2","alpha","stddev","size","z","t","x_","p_","lw","up","res","y_","mx","my","b1","b2","whipNumberArrays","s1","s2","s3","t1","t2","_mat_mean","Mat","height","_mat_devsq","mean","sq","Y","X","konst","stats","map","clone","eachRow","row","unshift","width","Xt","transpose","B","multiply","inverse","line_1","push","this","asMatrix","Y1","y_y1","adds","mp","SSreg","SSresid","line_5","R2","degfre","err_est","line_3","F_sta","line_4","SCP","line_2","W","new_X","root_newton","func","guess","max_it","eps","root","f_d","dx","rate","nper","pmt","pv","h1","h2","fv","xfd","per","ipmt","start","end","tn","ts","te","monthlyPayment","remainingBalanceAtStart","remainingBalanceAtEnd","cip","flows","npv","npv1","nominal_rate","npery","effect_rate","values","dates","cost","salvage","life","period","month","floor","db","factor","prior","dep","max","no_switch","interest","_getGDA","value","gda","oldValue","newValue","_interVDB","life1","term","remValue","intEnd","ceil","lia","vdb","nowLia","intStart","part","_edate","base","months","year","date","_daysBetween","from","to","basis","_borderCoupons","settlement","maturity","freq","sett","periods","prev","next","_borderCoupons_fw","first","frequency","settl","matur","borders","mat","daysInYear","yr","issue","par","year_days","brace","prev1","next1","nrc","accr","annual","_numCoupons","pr","redemption","investment","discount","yld","N","beg_settl","settl_end","beg_end","den","yf","dsm","dy","splice","1656","1670","Class","Ref","CellRef","RangeRef","UnionRef","NULL","NULLREF","code","prototype","toString","Context","extend","init","callback","formula","ss","parent","resolve","val","self","resolveCells","_resolve","error","Array","isArray","maybeRoundFloatErrors","arrayFormulaRange","_arrayArg","onFormula","context","formulas","loop","add","getRefCells","pending","fetch","exec","cell","cellValues","wantNulls","ret","getRefData","concat","Matrix","fetchName","ref","nameValue","sheet","col","Formula","ValidationFormulaContext","workbook","absolute","isMerged","topLeft","force","fname","toLowerCase","FUNCS","bool","bottomRight","setSheet","range","tl","top","left","cells","isFinite","forEach","set","line","el","isRange","each","isNaN","Number","refs","hiddenInfo","getData","slice","get","getNA","includeEmpty","eachCol","mapRow","mapCol","JSON","stringify","unit","va","vb","sign","determinant","C","L","augment","imax","argmax","pos","handler","printer","print","absrefs","onReady","setArrayFormulaRange","forceRefs","lcsheet","hasSheet","deepClone","parentContext","ctx","level","bind","setTimeout","reset","renameSheet","oldSheetName","newSheetName","adjust","affectedSheet","operation","formulaRow","formulaCol","formulaSheet","formulaMoves","newFormulaRow","newFormulaCol","prevRefs","modified","newRef","sameRef","prevRange","relative","r1","r2","constructor","rel","endSheet","Object","create","compileArgumentChecks","functionName","name","forced","arrayArgs","main","haveForced","canBeArrayArg","hasArrayArgs","comp","join","Function","limitPrecision","cond","test","charAt","substr","allowError","typeCheck","forceNum","round","err","num","parseInt","toPrecision","withErrorHandling","obj","makeSyncFunction","check","doit","result","xargs","arrays","makeAsyncFunction","count","makeCallback","console","kendoSpreadsheetArgs","argsAsync","dateToJulianDays","julianDaysToDate","jd","l","day","ord","ORDINAL_ADD_DAYS","co","th","comatrix","thmatrix","elmatrix","BASE_DATE","DAYS_IN_MONTH","mo","validDate","da","serial","MS_IN_MIN","MS_IN_HOUR","MS_IN_DAY","unpackTime","ms","hours","minutes","seconds","milliseconds","serialToDate","Date","packTime","hh","mm","dateToSerial","time","getHours","getMinutes","getSeconds","getMilliseconds","getFullYear","getMonth","getDate","parseDate","str","format","formatting","makeDateFormat","parseExactDate","dateToNumber","numberToDate","defineAlias","alias","orig","kendoSpreadsheetAliases","NUMBER_OR_ZERO","ARGS_NUMERIC","ARGS_ANYVALUE","equals","binaryCompare","right","intersect","1662","1671","util","NameRef","_cosh","_sinh","_tanh","_gcd","_lcm","forIFS","chunks","matrix","pred","parseCriteria","COL","rad","deg","cos","atan","tan","mode","mult","digits","numbers","reduce","prod","rest","coef","seen","indexOf","ARGS_COUNTIFS","c1","ARGS_SUMIFS","numericPredicate","criteria","ARGS_SUMIF","fetchSumRange","continuation","sumRange","toRangeRef","_avg","_var_sp","divisor","avg","_stdev_sp","_percentrank","exc","nlt","ngt","found","def","nth","sort","descending","ascending","discard","bins","asc","variance","ARGS_PERCENTRANK","_covariance","ax","ay","significance","toFixed","parseFloat","_fact","memoize","fact","div","_combinations","f1","f2","p1","p2","_percentile","rank","_percentile_inc","_percentile_exc","quarter","AGGREGATE_FUNCS","fetchValuesForAggregate","options","opt_ignore_hidden_rows","opt_ignore_errors","opt_use_aggregates","fetchValues","hidden","_binom_dist","weeksInYear","method","d1","funcId","ignoreHidden","arguments","a1","index","approx","resultCol","areanum","toCell","colRange","toColumn","rowRange","toRow","thing","parseFormula","ast","cmp","resultRow","diff","fw","sy","dow","wk","holidays","inc","text","match","ampm","random","arabicToRoman","toUpperCase","rom","romanToArabic","number","radix","minLen","charCodeAt","String","fromCharCode","RX_NON_PRINTABLE","Hyperlink","link","replace","out","decimals","dec","denomitator","substring","string","noCommas","scale","newText","oldText","split","valueIfError","RXCACHE","makeComparator","lc","compLT","compLTE","compGT","compGTE","compNE","compEQ","RegExp","rx"],"mappings":"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","file":"js/chunk-vendors~d0bb85bb.acf4261e.js","sourcesContent":["module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ (function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(1672);\n\tmodule.exports = __webpack_require__(1672);\n\n\n/***/ }),\n\n/***/ 3:\n/***/ (function(module, exports) {\n\n\tmodule.exports = function() { throw new Error(\"define cannot be used indirect\"); };\r\n\n\n/***/ }),\n\n/***/ 1628:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"./runtime\");\n\n/***/ }),\n\n/***/ 1672:\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// -*- fill-column: 100 -*-\n\n\t(function(f, define){\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ __webpack_require__(1628) ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t})(function(){\n\t    \"use strict\";\n\n\t    // WARNING: removing the following jshint declaration and turning\n\t    // == into === to make JSHint happy will break functionality.\n\t    /* jshint eqnull:true, newcap:false, laxbreak:true, validthis:true */\n\t    /* jshint latedef: nofunc */\n\n\t    var spreadsheet = kendo.spreadsheet;\n\t    var calc = spreadsheet.calc;\n\t    var runtime = calc.runtime;\n\t    var defineFunction = runtime.defineFunction;\n\t    var CalcError = runtime.CalcError;\n\t    var packDate = runtime.packDate;\n\t    var unpackDate = runtime.unpackDate;\n\t    var isLeapYear = runtime.isLeapYear;\n\t    var daysInMonth = runtime.daysInMonth;\n\t    var _days_360 = runtime._days_360;\n\n\t    /* -----[ Spreadsheet API ]----- */\n\n\t    defineFunction(\"ERF\", function(ll, ul) {\n\t        if (ul == null) {\n\t            return ERF(ll);\n\t        }\n\t        return ERF(ul) - ERF(ll);\n\t    }).args([\n\t        [ \"lower_limit\", \"number\" ],\n\t        [ \"upper_limit\", [ \"or\", \"number\", \"null\" ] ]\n\t    ]);\n\n\t    defineFunction(\"ERFC\", ERFC).args([\n\t        [ \"x\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"GAMMALN\", GAMMALN).args([\n\t        [ \"x\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"GAMMA\", GAMMA).args([\n\t        [ \"x\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"GAMMA.DIST\", GAMMA_DIST).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"alpha\", \"number++\" ],\n\t        [ \"beta\", \"number++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"GAMMA.INV\", GAMMA_INV).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"alpha\", \"number++\" ],\n\t        [ \"beta\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"NORM.S.DIST\", NORM_S_DIST).args([\n\t        [ \"z\", \"number\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"NORM.S.INV\", NORM_S_INV).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"NORM.DIST\", NORM_DIST).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"mean\", \"number\" ],\n\t        [ \"stddev\", \"number++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"NORM.INV\", NORM_INV).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"mean\", \"number\" ],\n\t        [ \"stddev\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"BETADIST\", BETADIST).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"alpha\", \"number++\" ],\n\t        [ \"beta\", \"number++\" ],\n\t        [ \"A\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"B\", [ \"or\", \"number\", [ \"null\", 1 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$x >= $A\", \"NUM\" ] ],\n\t        [ \"?\", [ \"assert\", \"$x <= $B\", \"NUM\" ] ],\n\t        [ \"?\", [ \"assert\", \"$A < $B\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"BETA.DIST\", BETA_DIST).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"alpha\", \"number++\" ],\n\t        [ \"beta\", \"number++\" ],\n\t        [ \"cumulative\", \"logical\" ],\n\t        [ \"A\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"B\", [ \"or\", \"number\", [ \"null\", 1 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$x >= $A\", \"NUM\" ] ],\n\t        [ \"?\", [ \"assert\", \"$x <= $B\", \"NUM\" ] ],\n\t        [ \"?\", [ \"assert\", \"$A < $B\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"BETA.INV\", BETA_INV).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"alpha\", \"number++\" ],\n\t        [ \"beta\", \"number++\" ],\n\t        [ \"A\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"B\", [ \"or\", \"number\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"CHISQ.DIST\", chisq_left).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"deg_freedom\", \"integer++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"CHISQ.DIST.RT\", chisq_right).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"CHISQ.INV\", chisq_left_inv).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"CHISQ.INV.RT\", chisq_right_inv).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"CHISQ.TEST\", function(ac, ex){\n\t        return chisq_test(ac.data, ex.data);\n\t    }).args([\n\t        [ \"actual_range\", \"matrix\" ],\n\t        [ \"expected_range\", \"matrix\" ],\n\t        [ \"?\", [ \"assert\", \"$actual_range.width == $expected_range.width\" ] ],\n\t        [ \"?\", [ \"assert\", \"$actual_range.height == $expected_range.height\" ] ]\n\t    ]);\n\n\t    defineFunction(\"EXPON.DIST\", expon).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"lambda\", \"number++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"POISSON.DIST\", poisson).args([\n\t        [ \"x\", \"integer+\" ],\n\t        [ \"mean\", \"number+\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"F.DIST\", Fdist).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"deg_freedom1\", \"integer++\" ],\n\t        [ \"deg_freedom2\", \"integer++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"F.DIST.RT\", Fdist_right).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"deg_freedom1\", \"integer++\" ],\n\t        [ \"deg_freedom2\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"F.INV\", Finv).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom1\", \"integer++\" ],\n\t        [ \"deg_freedom2\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"F.INV.RT\", Finv_right).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom1\", \"integer++\" ],\n\t        [ \"deg_freedom2\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"F.TEST\", Ftest).args([\n\t        [ \"array1\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"array2\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length >= 2\", \"DIV/0\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array2.length >= 2\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"FISHER\", fisher).args([\n\t        [ \"x\", [ \"and\", \"number\", [ \"(between)\", -1, 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"FISHERINV\", fisherinv).args([\n\t        [ \"y\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"T.DIST\", Tdist).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"deg_freedom\", \"integer++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"T.DIST.RT\", Tdist_right).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"T.DIST.2T\", Tdist_2tail).args([\n\t        [ \"x\", \"number+\" ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"T.INV\", Tdist_inv).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"(between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"T.INV.2T\", Tdist_2tail_inv).args([\n\t        [ \"p\", [ \"and\", \"number\", [ \"(between]\", 0, 1 ] ] ],\n\t        [ \"deg_freedom\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"T.TEST\", Tdist_test).args([\n\t        [ \"array1\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"array2\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"tails\", [ \"and\", \"integer\", [ \"values\", 1, 2 ] ] ],\n\t        [ \"type\", [ \"and\", \"integer\", [ \"values\", 1, 2, 3 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$type != 1 || $array1.length == $array2.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length >= 2\", \"DIV/0\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array2.length >= 2\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"CONFIDENCE.T\", confidence_t).args([\n\t        [ \"alpha\", [ \"and\", \"number\", [ \"(between)\", 0, 1 ] ] ],\n\t        [ \"standard_dev\", \"number++\" ],\n\t        [ \"size\", [ \"and\", \"integer++\",\n\t                    [ \"assert\", \"$size != 1\", \"DIV/0\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"CONFIDENCE.NORM\", confidence_norm).args([\n\t        [ \"alpha\", [ \"and\", \"number\", [ \"(between)\", 0, 1 ] ] ],\n\t        [ \"standard_dev\", \"number++\" ],\n\t        [ \"size\", [ \"and\", \"integer++\" ] ]\n\t    ]);\n\n\t    defineFunction(\"GAUSS\", gauss).args([\n\t        [ \"z\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"PHI\", phi).args([\n\t        [ \"x\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"LOGNORM.DIST\", lognorm_dist).args([\n\t        [ \"x\", \"number++\" ],\n\t        [ \"mean\", \"number\" ],\n\t        [ \"standard_dev\", \"number++\" ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineFunction(\"LOGNORM.INV\", lognorm_inv).args([\n\t        [ \"probability\", [ \"and\", \"number\", [ \"(between)\", 0, 1 ] ] ],\n\t        [ \"mean\", \"number\" ],\n\t        [ \"standard_dev\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"PROB\", prob).args([\n\t        [ \"x_range\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"prob_range\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"lower_limit\", \"number\" ],\n\t        [ \"upper_limit\", [ \"or\", \"number\", [ \"null\", \"$lower_limit\" ] ] ],\n\t        [ \"?\", [ \"assert\", \"$prob_range.length == $x_range.length\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"SLOPE\", slope).args([\n\t        [ \"known_y\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"known_x\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length == $known_y.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length > 0 && $known_y.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"INTERCEPT\", intercept).args([\n\t        [ \"known_y\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"known_x\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length == $known_y.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length > 0 && $known_y.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"PEARSON\", pearson).args([\n\t        [ \"array1\", [ \"collect!\", \"anything\", 1 ] ],\n\t        [ \"array2\", [ \"collect!\", \"anything\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$array2.length == $array1.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array2.length > 0 && $array1.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"RSQ\", rsq).args([\n\t        [ \"known_y\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"known_x\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length == $known_y.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length > 0 && $known_y.length > 0\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length != 1 && $known_y.length != 1\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"STEYX\", steyx).args([\n\t        [ \"known_y\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"known_x\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length == $known_y.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length >= 3 && $known_y.length >= 3\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"FORECAST\", forecast).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"known_y\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"known_x\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length == $known_y.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$known_x.length > 0 && $known_y.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"LINEST\", linest).args([\n\t        [ \"known_y\", \"matrix\" ],\n\t        [ \"known_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"const\", [ \"or\", \"logical\", [ \"null\", true ] ] ],\n\t        [ \"stats\", [ \"or\", \"logical\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    defineFunction(\"LOGEST\", logest).args([\n\t        [ \"known_y\", \"matrix\" ],\n\t        [ \"known_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"const\", [ \"or\", \"logical\", [ \"null\", true ] ] ],\n\t        [ \"stats\", [ \"or\", \"logical\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    defineFunction(\"TREND\", trend).args([\n\t        [ \"known_y\", \"matrix\" ],\n\t        [ \"known_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"new_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"const\", [ \"or\", \"logical\", [ \"null\", true ] ] ]\n\t    ]);\n\n\t    defineFunction(\"GROWTH\", growth).args([\n\t        [ \"known_y\", \"matrix\" ],\n\t        [ \"known_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"new_x\", [ \"or\", \"matrix\", \"null\" ] ],\n\t        [ \"const\", [ \"or\", \"logical\", [ \"null\", true ] ] ]\n\t    ]);\n\n\t    defineFunction(\"FV\", FV).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"nper\", \"number\" ],\n\t        [ \"pmt\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"pv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$pmt || $pv\" ] ]\n\t    ]);\n\n\t    defineFunction(\"PV\", PV).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"nper\", \"number\" ],\n\t        [ \"pmt\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"PMT\", PMT).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"nper\", \"number\" ],\n\t        [ \"pmt\", \"number\" ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"NPER\", NPER).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"pmt\", \"number\" ],\n\t        [ \"pv\", \"number\" ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"RATE\", RATE).args([\n\t        [ \"nper\", \"number\" ],\n\t        [ \"pmt\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"pv\", \"number\" ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"guess\", [ \"or\", \"number++\", [ \"null\", 0.01 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$pmt || $fv\" ] ]\n\t    ]);\n\n\t    defineFunction(\"IPMT\", IPMT).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"per\", \"number++\" ],\n\t        [ \"nper\", \"number++\" ],\n\t        [ \"pv\", \"number\" ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$per >= 1 && $per <= $nper\" ] ]\n\t    ]);\n\n\t    defineFunction(\"PPMT\", PPMT).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"per\", \"number++\" ],\n\t        [ \"nper\", \"number++\" ],\n\t        [ \"pv\", \"number\" ],\n\t        [ \"fv\", [ \"or\", \"number\", [ \"null\", 0 ] ] ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$per >= 1 && $per <= $nper\" ] ]\n\t    ]);\n\n\t    defineFunction(\"CUMPRINC\", CUMPRINC).args([\n\t        [ \"rate\", \"number++\" ],\n\t        [ \"nper\", \"number++\" ],\n\t        [ \"pv\", \"number++\" ],\n\t        [ \"start_period\", \"number++\" ],\n\t        [ \"end_period\", \"number++\" ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$end_period >= $start_period\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"CUMIPMT\", CUMIPMT).args([\n\t        [ \"rate\", \"number++\" ],\n\t        [ \"nper\", \"number++\" ],\n\t        [ \"pv\", \"number++\" ],\n\t        [ \"start_period\", \"number++\" ],\n\t        [ \"end_period\", \"number++\" ],\n\t        [ \"type\", [ \"or\", [ \"values\", 0, 1 ], [ \"null\", 0 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$end_period >= $start_period\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"NPV\", NPV).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"values\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$values.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"IRR\", IRR).args([\n\t        [ \"values\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"guess\", [ \"or\", \"number\", [ \"null\", 0.1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"EFFECT\", EFFECT).args([\n\t        [ \"nominal_rate\", \"number++\" ],\n\t        [ \"npery\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"NOMINAL\", NOMINAL).args([\n\t        [ \"effect_rate\", \"number++\" ],\n\t        [ \"npery\", \"integer++\" ]\n\t    ]);\n\n\t    defineFunction(\"XNPV\", XNPV).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"values\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"dates\", [ \"collect\", \"date\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$values.length == $dates.length\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"XIRR\", XIRR).args([\n\t        [ \"values\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"dates\", [ \"collect\", \"date\", 1 ] ],\n\t        [ \"guess\", [ \"or\", \"number\", [ \"null\", 0.1 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$values.length == $dates.length\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"ISPMT\", ISPMT).args([\n\t        [ \"rate\", \"number\" ],\n\t        [ \"per\", \"number++\" ],\n\t        [ \"nper\", \"number++\" ],\n\t        [ \"pv\", \"number\" ],\n\t        [ \"?\", [ \"assert\", \"$per >= 1 && $per <= $nper\" ] ]\n\t    ]);\n\n\t    defineFunction(\"DB\", DB).args([\n\t        [ \"cost\", \"number\" ],\n\t        [ \"salvage\", \"number\" ],\n\t        [ \"life\", \"number++\" ],\n\t        [ \"period\", \"number++\" ],\n\t        [ \"month\", [ \"or\", \"number\", [ \"null\", 12 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"DDB\", DDB).args([\n\t        [ \"cost\", \"number\" ],\n\t        [ \"salvage\", \"number\" ],\n\t        [ \"life\", \"number++\" ],\n\t        [ \"period\", \"number++\" ],\n\t        [ \"factor\", [ \"or\", \"number\", [ \"null\", 2 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"SLN\", SLN).args([\n\t        [ \"cost\", \"number\" ],\n\t        [ \"salvage\", \"number\" ],\n\t        [ \"life\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"SYD\", SYD).args([\n\t        [ \"cost\", \"number\" ],\n\t        [ \"salvage\", \"number\" ],\n\t        [ \"life\", \"number++\" ],\n\t        [ \"per\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"VDB\", VDB).args([\n\t        [ \"cost\", \"number+\" ],\n\t        [ \"salvage\", \"number+\" ],\n\t        [ \"life\", \"number++\" ],\n\t        [ \"start_period\", \"number+\" ],\n\t        [ \"end_period\", \"number+\" ],\n\t        [ \"factor\", [ \"or\", \"number+\", [ \"null\", 2 ] ] ],\n\t        [ \"no_switch\", [ \"or\", \"logical\", [ \"null\", false ] ] ],\n\t        [ \"?\", [ \"assert\", \"$end_period >= $start_period\", \"NUM\" ] ]\n\t    ]);\n\n\t    var COUPS_ARGS = [\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"frequency\", [ \"and\", \"integer\", [ \"values\", 1, 2, 4 ] ] ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ];\n\n\t    defineFunction(\"COUPDAYBS\", COUPDAYBS).args(COUPS_ARGS);\n\n\t    defineFunction(\"COUPDAYS\", COUPDAYS).args(COUPS_ARGS);\n\n\t    defineFunction(\"COUPDAYSNC\", COUPDAYSNC).args(COUPS_ARGS);\n\n\t    defineFunction(\"COUPPCD\", COUPPCD).args(COUPS_ARGS);\n\n\t    defineFunction(\"COUPNCD\", COUPNCD).args(COUPS_ARGS);\n\n\t    defineFunction(\"COUPNUM\", COUPNUM).args(COUPS_ARGS);\n\n\t    defineFunction(\"ACCRINTM\", ACCRINTM).args([\n\t        [ \"issue\", \"date\" ],\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"rate\", \"number++\" ],\n\t        [ \"par\", [ \"or\", [ \"null\", 1000 ], \"number++\" ] ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$issue < $settlement\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"ACCRINT\", ACCRINT).args([\n\t        [ \"issue\", \"date\" ],\n\t        [ \"first_interest\", \"date\" ],\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"rate\", \"number++\" ],\n\t        [ \"par\", [ \"or\", [ \"null\", 1000 ], \"number++\" ] ],\n\t        [ \"frequency\", [ \"and\", \"integer\", [ \"values\", 1, 2, 4 ] ] ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"calc_method\", [ \"or\", \"logical\", [ \"null\", true ] ] ],\n\t        [ \"?\", [ \"assert\", \"$issue < $settlement\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"DISC\", DISC).args([\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"pr\", \"number++\" ],\n\t        [ \"redemption\", \"number++\" ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"INTRATE\", INTRATE).args([\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"investment\", \"number++\" ],\n\t        [ \"redemption\", \"number++\" ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"RECEIVED\", RECEIVED).args([\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"investment\", \"number++\" ],\n\t        [ \"discount\", \"number++\" ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"PRICE\", PRICE).args([\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"rate\", \"number++\" ],\n\t        [ \"yld\", \"number++\" ],\n\t        [ \"redemption\", \"number++\" ],\n\t        [ \"frequency\", [ \"and\", \"integer\", [ \"values\", 1, 2, 4 ] ] ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"PRICEDISC\", PRICEDISC).args([\n\t        [ \"settlement\", \"date\" ],\n\t        [ \"maturity\", \"date\" ],\n\t        [ \"discount\", \"number++\" ],\n\t        [ \"redemption\", \"number++\" ],\n\t        [ \"basis\", [ \"or\", [ \"null\", 0 ],\n\t                     [ \"and\", \"integer\", [ \"values\", 0, 1, 2, 3, 4 ] ] ] ],\n\t        [ \"?\", [ \"assert\", \"$settlement < $maturity\", \"NUM\" ] ]\n\t    ]);\n\n\t    /* -----[ utils ]----- */\n\n\t    // function resultAsMatrix(f) {\n\t    //     return function() {\n\t    //         var a = f.apply(this, arguments);\n\t    //         return this.asMatrix(a);\n\t    //     };\n\t    // }\n\n\t    /* -----[ definitions: statistical functions ]----- */\n\n\t    var MAX_IT = 300,     // Maximum allowed number of iterations\n\t        EPS = 2.2204e-16, // Relative accuracy; 1-3*(4/3-1) = 2.220446049250313e-16\n\t        FP_MIN = 1.0e-30, // Near the smallest representable as floating-point, number.\n\t        f_abs = Math.abs;\n\n\t    function ERF(x) {\n\t        if (f_abs(x) >= 3.3) {\n\t            return 1 - ERFC(x);\n\t        }\n\t        var S = x > 0 ? 1 : -1;\n\t        if (S == -1) {\n\t            x = -x;\n\t        }\n\t        var m = 0, an = 1;\n\t        for (var n = 1; n < 100; n++) {\n\t            m += an;\n\t            an *= 2*x*x/(2*n+1);\n\t        }\n\t        return S*2/Math.sqrt(Math.PI)*x*Math.exp(-x*x)*m;\n\t    }\n\n\t    function ERFC(x) {\n\t        if (f_abs(x) < 3.3) {\n\t            return 1 - ERF(x);\n\t        }\n\t        var s = 1;\n\t        if (x < 0) {\n\t            s = -1;\n\t            x = -x;\n\t        }\n\t        var frac = x;\n\t        for (var n = 8; n >= 1; n -= 0.5) {\n\t            frac = x + n/frac;\n\t        }\n\t        frac = 1 / (x + frac);\n\t        return s == 1\n\t            ? Math.exp(-x*x)/Math.sqrt(Math.PI)*frac\n\t            : 2 - Math.exp(-x*x)/Math.sqrt(Math.PI)*frac;\n\t    }\n\n\t    function GAMMALN(x) { // Returns the value ln[Γ(x)] for x > 0.\n\t        var cof = [\n\t            1.000000000190015, 76.18009172947146, -86.50532032941677,\n\t            24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5\n\t        ];\n\t        var y = x, tmp = x + 5.5, ser = cof[0];\n\t        tmp -= (x + 0.5) * Math.log(tmp);\n\t        for (var j = 1; j <= 6; j++) {\n\t            y += 1;\n\t            ser += cof[j] / y;\n\t        }\n\t        return -tmp + Math.log(Math.sqrt(2*Math.PI) * ser / x); // log(Γ(x)) = log(Γ(x+1)) - log(x)\n\t    }\n\n\t    function GAMMA(x) { // returns Infinity for 0 or negative _integer argument.\n\t        if (x > 0) {\n\t            return Math.exp(GAMMALN(x));\n\t        }\n\t        var pi = Math.PI, y = -x; // For x<0 we use the reflection formula: Γ(x)Γ(1-x) = PI / sin(PI*x)\n\t        return -pi / (y*GAMMA(y)*Math.sin(pi*y));\n\t    }\n\n\t    function BETALN(a, b) {\n\t        return GAMMALN(a) + GAMMALN(b) - GAMMALN(a+b);\n\t    }\n\n\t    function BETA(a, b) {\n\t        return Math.exp(BETALN(a, b));\n\t    }\n\n\t    function gamma_inc(a, x) { // returns the normalized incomplete gamma function P(a, x); x > 0.\n\t        return x < a+1.0 ? g_series(a, x) : 1 - g_contfrac(a, x);\n\t    }\n\n\t    function g_series(a, x) { // evaluate P(a, x) by its series representation (converges quickly for x < a+1).\n\t        var sum = 1/a,\n\t            frac = sum,\n\t            ap = a;\n\t        var gln = GAMMALN(a), n;\n\t        for (n = 1; n <= MAX_IT; n++) {\n\t            ap++;\n\t            frac *= x/ap;\n\t            sum += frac;\n\t            if (f_abs(frac) < f_abs(sum)*EPS) {\n\t                break; // already the last frac is too small versus the current sum value\n\t            }\n\t        }\n\t        return sum * Math.exp(-x + a*Math.log(x) - gln); // e^{-x} * x^a * Γ(a) * sum\n\t    }\n\n\t    function g_contfrac(a, x) { // Q(a, x) by its continued fraction representation (converges quickly for x > a + 1); modified Lentz’s method (Numerical Recipes (The Art of Scientific Computing), 2rd Edition $5.2)\n\t        var f = FP_MIN, c = f, d = 0, aj = 1, bj = x + 1 - a;\n\t        var gln = GAMMALN(a);\n\t        for (var i = 1; i <= MAX_IT; i++) {\n\t            d = bj + aj * d;\n\t\t    if (f_abs(d) < FP_MIN) {\n\t                d = FP_MIN;\n\t            }\n\t\t    c = bj + aj / c;\n\t\t    if (f_abs(c) < FP_MIN) {\n\t                c = FP_MIN;\n\t            }\n\t\t    d = 1 / d;\n\t\t    var delta = c * d;\n\t\t    f *= delta;\n\t    \t    if (f_abs(delta - 1) < EPS) {\n\t                break;\n\t            }\n\t\t    bj += 2;\n\t\t    aj = -i * (i - a);\n\t\t}\n\t\treturn f * Math.exp(-x - gln + a * Math.log(x));\n\t    }\n\n\t    function GAMMA_DIST(x, a, b, cumulative) { // a > 0, b > 0; x >= 0\n\t        if (!cumulative) {\n\t            return Math.pow(x/b, a-1)*Math.exp(-x/b)/(b*GAMMA(a)); // the PDF of the Gamma distribution\n\t        }\n\t        return gamma_inc(a, x/b); // (else) compute the CDF (using the incomplete Gamma function)\n\t    }\n\n\t    function GAMMA_INV(p, a, b) { // the quantile function of the Gamma distribution\n\t\tif (p === 0) {\n\t            return 0;\n\t        }\n\t\tif (p == 1) {\n\t            return Infinity;\n\t        }\n\t\tvar m = 0, M = 10, x = 0, ab = a*b;\n\t\tif (ab > 1) {\n\t            M *= ab;\n\t        }\n\t\tfor (var i = 0; i < MAX_IT; i++) {\n\t\t    x = 0.5*(m + M); // console.log(x);\n\t\t    var q = GAMMA_DIST(x, a, b, true);\n\t\t    if (f_abs(p - q) < 1e-16) {\n\t                break;\n\t            }\n\t\t    if (q > p) {\n\t                M = x;\n\t            } else {\n\t                m = x;\n\t            }\n\t\t}\n\t\treturn x;\n\t    }\n\n\t    function NORM_S_DIST(x, cumulative) {\n\t        if (!cumulative) {\n\t            return Math.exp(-x*x/2)/Math.sqrt(2*Math.PI);\n\t        }\n\t        return 0.5 + 0.5*ERF(x/Math.sqrt(2));\n\t    }\n\n\t    function NORM_S_INV(p) { // see [1] $26.2.3 and http://home.online.no/~pjacklam/notes/invnorm/#References\n\t        // Coefficients in rational approximations.\n\t        var a = [-3.969683028665376e+01,  2.209460984245205e+02,\n\t                 -2.759285104469687e+02,  1.383577518672690e+02,\n\t                 -3.066479806614716e+01,  2.506628277459239e+00],\n\t            b = [-5.447609879822406e+01,  1.615858368580409e+02,\n\t                 -1.556989798598866e+02,  6.680131188771972e+01,\n\t                 -1.328068155288572e+01],\n\t            c = [-7.784894002430293e-03, -3.223964580411365e-01,\n\t                 -2.400758277161838e+00, -2.549732539343734e+00,\n\t                 4.374664141464968e+00,  2.938163982698783e+00],\n\t            d = [ 7.784695709041462e-03,  3.224671290700398e-01,\n\t                  2.445134137142996e+00,  3.754408661907416e+00];\n\t        // Define break-points.\n\t        var plow  = 0.02425,\n\t            phigh = 1 - plow;\n\t        var q, r;\n\t        // Rational approximation for lower region:\n\t        if (p < plow) {\n\t            q = Math.sqrt(-2*Math.log(p));\n\t            return (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) / ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);\n\t        }\n\t        // Rational approximation for upper region:\n\t        if (phigh < p) {\n\t            q = Math.sqrt(-2*Math.log(1-p));\n\t            return -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) / ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);\n\t        }\n\t        // Rational approximation for central region:\n\t        q = p - 0.5;\n\t        r = q*q;\n\t        return (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q / (((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1);\n\t    }\n\n\t    function NORM_DIST(x, m, s, cumulative) {\n\t        if (!cumulative) {\n\t            return Math.exp(-(x-m)*(x-m)/(2*s*s))/(s*Math.sqrt(2*Math.PI)); // NORM_S_DIST((x-m)/s)/s;\n\t        }\n\t        return NORM_S_DIST((x-m)/s, true);\n\t    }\n\n\t    function NORM_INV(p, m, s) {\n\t        return m + s*NORM_S_INV(p);\n\t    }\n\n\t    function betastd_pdf(x, a, b) {\n\t        return Math.exp((a-1)*Math.log(x) + (b-1)*Math.log(1-x) - BETALN(a, b));\n\t    }\n\n\t    function betastd_cdf(x, a, b) {\n\t        var k = Math.exp(a*Math.log(x) + b*Math.log(1-x) - BETALN(a, b));\n\t        return x < (a+1)/(a+b+2) ? k*beta_lentz(a, b, x)/a : 1 - k*beta_lentz(b, a, 1-x)/b;\n\t    }\n\n\t    function beta_lentz(a, b, x) { // estimates continued fraction by modified Lentz’s method ([2] $8.17.22)\n\t        var m, m2;\n\t        var aa, c, d, del, h, qab, qam, qap;\n\t        qab = a + b; // These q’s will be used in factors that occur in the coefficients d_n\n\t        qap = a + 1;\n\t        qam = a - 1;\n\t        c = 1; // First step of Lentz’s method.\n\t        d = 1 - qab * x / qap;\n\t        if (f_abs(d) < FP_MIN) {\n\t            d = FP_MIN;\n\t        }\n\t        d = 1/d;\n\t        h = d;\n\t        for (m = 1; m <= MAX_IT; m++) {\n\t            m2 = 2*m;\n\t            aa = m*(b - m)*x / ((qam + m2)*(a + m2));\n\t            d = 1 + aa*d; // One step (the even one) of the recurrence.\n\t            if (f_abs(d) < FP_MIN) {\n\t                d = FP_MIN;\n\t            }\n\t            c = 1 + aa/c;\n\t            if (f_abs(c) < FP_MIN) {\n\t                c = FP_MIN;\n\t            }\n\t            d = 1/d;\n\t            h *= d*c;\n\t            aa = -(a + m)*(qab + m)*x / ((a + m2)*(qap + m2));\n\t            d = 1 + aa*d; // Next step of the recurrence (the odd one).\n\t            if (f_abs(d) < FP_MIN) {\n\t                d = FP_MIN;\n\t            }\n\t            c = 1 + aa/c;\n\t            if (f_abs(c) < FP_MIN) {\n\t                c = FP_MIN;\n\t            }\n\t            d = 1/d;\n\t            del = d*c;\n\t            h *= del;\n\t            if (f_abs(del - 1) < EPS) {\n\t                break;\n\t            }\n\t        }\n\t        return h; // if(m > MAX_IT) throw new Error(\"a or b too big, or MAX_IT too small\");\n\t    }\n\n\t    function betastd_inv(p, a, b) { // the quantile function of the standard Beta distribution\n\t\tvar m = 0, M = 1, x = 0;\n\t\tfor (var i = 0; i < MAX_IT; i++) {\n\t\t    x = 0.5*(m + M);\n\t\t    var q = betastd_cdf(x, a, b);\n\t\t    if (f_abs(p - q) < EPS) {\n\t                break;\n\t            }\n\t\t    if (q > p) {\n\t                M = x;\n\t            } else {\n\t                m = x;\n\t            }\n\t\t}\n\t\treturn x;\n\t    }\n\n\t    function BETADIST(x, a, b, m, M) {\n\t        return betastd_cdf((x-m)/(M-m), a, b);\n\t    }\n\n\t    function BETA_DIST(x, a, b, cdf, m, M) {\n\t        if (cdf) {\n\t            return betastd_cdf((x-m)/(M-m), a, b);\n\t        }\n\t        return betastd_pdf((x-m)/(M-m), a, b) / (M-m);\n\t    }\n\n\t    function BETA_INV(p, a, b, m, M) {\n\t        return m + (M-m)*betastd_inv(p, a, b);\n\t    }\n\n\t    function chisq_left(x, n, cds) {  // CHISQ.DIST(x,deg_freedom,cumulative)\n\t        return GAMMA_DIST(x, n/2, 2, cds);\n\t    }\n\n\t    function chisq_right(x, n) { // CHISQ.DIST.RT(x,deg_freedom)\n\t        return 1 - chisq_left(x, n, true);\n\t    }\n\n\t    function chisq_left_inv(p, n) { // CHISQ.INV( probability, degrees_freedom )\n\t        return GAMMA_INV(p, n/2, 2);\n\t    }\n\n\t    function chisq_right_inv(p, n) { // CHISQ.INV.RT(probability,deg_freedom)\n\t        return chisq_left_inv(1-p, n);\n\t    }\n\n\t    function chisq_test(obsv, expect) {\n\t        var rows = obsv.length, cols = obsv[0].length;\n\t        var x = 0, i, j;\n\t        for (i = 0; i < rows; i++) {\n\t            for (j = 0; j < cols; j++) {\n\t                var eij = expect[i][j];\n\t                var delta = obsv[i][j] - eij;\n\t                delta *= delta;\n\t                x += delta/eij;\n\t            }\n\t        }\n\t        var n = (rows - 1)*(cols - 1);\n\t        return chisq_right(x, n);\n\t    }\n\n\t    function expon(x, r, cdf) { // EXPON.DIST(x, lambda, cumulative)\n\t        if (cdf) {\n\t            return 1 - Math.exp(-r*x);\n\t        }\n\t        return r * Math.exp(-r*x);\n\t    }\n\n\t    function poisson(k, m, cdf) { // POISSON.DIST(x, mean, cumulative)\n\t        if (cdf) {\n\t            return 1 - chisq_left(2*m, 2*(k+1), true);\n\t        }\n\t        //return chisq_left(2*m, 2*k, true) - chisq_left(2*m, 2*(k+1), true);\n\t        var lnf = 0;\n\t        for (var i = 2; i <= k; i++) {\n\t            lnf += Math.log(i); // compute log(k!)\n\t        }\n\t        return Math.exp(k*Math.log(m) - m - lnf);\n\t    }\n\n\t    function Fdist(x, n, d, cdf) { //F.DIST(x,deg_freedom1,deg_freedom2,cumulative)\n\t        if (cdf) {\n\t            return betastd_cdf(n*x/(d+n*x), n/2, d/2);\n\t        }\n\t        var u = n/d;\n\t        n /= 2; d /= 2;\n\t        return u/BETA(n, d) * Math.pow(u*x, n-1) / Math.pow(1+u*x, n+d);\n\t    }\n\n\t    function Fdist_right(x, n, d) { // F.DIST.RT(x,deg_freedom1,deg_freedom2)\n\t        return 1 - Fdist(x, n, d, true);\n\t    }\n\n\t    function Finv_right(p, n, d) { // F.INV.RT(probability,deg_freedom1,deg_freedom2\n\t        return d/n*(1/BETA_INV(p, d/2, n/2, 0, 1) - 1);\n\t    }\n\n\t    function Finv(p, n, d) { // F.INV(probability,deg_freedom1,deg_freedom2\n\t        return d/n*(1/BETA_INV(1-p, d/2, n/2, 0, 1) - 1);\n\t    }\n\n\t    function _mean(arr) {\n\t        var me = 0, n = arr.length;\n\t        for (var i = 0; i < n; i++) {\n\t            me += arr[i];\n\t        }\n\t        return me / n;\n\t    }\n\n\t    function _var_sq(arr, m) { // returns the (n-1)-part of the sum of the squares of deviations from m (= VAR)\n\t        var v = 0, n = arr.length;\n\t        for (var i = 0; i < n; i++) {\n\t            var delta = arr[i] - m;\n\t            v += delta*delta;\n\t        }\n\t        return v / (n-1);\n\t    }\n\n\t    function Ftest(arr1, arr2) { // F.TEST(array1,array2)\n\t        var n1 = arr1.length - 1, n2 = arr2.length - 1;\n\t        var va1 = _var_sq(arr1, _mean(arr1)),\n\t            va2 = _var_sq(arr2, _mean(arr2));\n\t        if (!va1 || !va2) {\n\t            throw new CalcError(\"DIV/0\");\n\t        }\n\t        return 2*Fdist(va1 / va2, n1, n2, true);\n\t    }\n\n\t    function fisher(x) { // FISHER(x)\n\t        return 0.5*Math.log((1+x)/(1-x));\n\t    }\n\n\t    function fisherinv(x) { // FISHERINV(x)\n\t        var e2 = Math.exp(2*x);\n\t        return (e2 - 1)/(e2 + 1);\n\t    }\n\n\t    function Tdist(x, n, cdf) { // T.DIST(x,deg_freedom, cumulative)\n\t        if (cdf) {\n\t            return 1 - 0.5*betastd_cdf(n/(x*x+n), n/2, 0.5);\n\t        }\n\t        return 1/(Math.sqrt(n)*BETA(0.5, n/2)) * Math.pow(1 + x*x/n, -(n+1)/2);\n\t    }\n\n\t    function Tdist_right(x, n) { // T.DIST.RT(x,deg_freedom)\n\t        return 1 - Tdist(x, n, true);\n\t    }\n\n\t    function Tdist_2tail(x, n) { // T.DIST.2T(x,deg_freedom)\n\t        if (x < 0) {\n\t            x = -x;\n\t        }\n\t        return 2*Tdist_right(x, n);\n\t    }\n\n\t    function Tdist_inv(p, n) { // T.INV(probability,deg_freedom)\n\t        var x = betastd_inv(2*Math.min(p, 1-p), n/2, 0.5); // ibetainv();\n\t        x = Math.sqrt(n * (1 - x) / x);\n\t        return (p > 0.5) ? x : -x;\n\t    }\n\n\t    function Tdist_2tail_inv(p, n) { // T.INV.2T(probability,deg_freedom)\n\t        // T2 = 2T_r = p => T_r(x,n) = p/2 => 1 - T(x,n,true) = p/2 => x = T^-1(1-p/2, n)\n\t        return Tdist_inv(1-p/2, n);\n\t    }\n\n\t    function Tdist_test(gr1, gr2, tail, type) { // T.TEST(array1,array2,tails,type)\n\t        var n1 = gr1.length, n2 = gr2.length;\n\t        var t_st, df; // the t-statistic and the \"degree of freedom\"\n\t        if (type == 1) { // paired (dependent) samples\n\t            var d = 0, d2 = 0;\n\t            for (var i = 0; i < n1; i++) {\n\t                var delta = gr1[i] - gr2[i];\n\t                d += delta;\n\t                d2 += delta*delta;\n\t            }\n\t            var md = d/n1; //, md2 = d2 / n1;\n\t            t_st = md / Math.sqrt((d2 - d*md)/(n1*(n1-1))); // has a \"Student T\" distribution\n\t            return tail == 1 ? Tdist_right(t_st, n1-1) : Tdist_2tail(t_st, n1-1);\n\t        }\n\t        // unpaired (independent) samples\n\t        var m1 = _mean(gr1), m2 = _mean(gr2),\n\t            v1 = _var_sq(gr1, m1), v2 = _var_sq(gr2, m2);\n\t        if (type == 3) { // unpaired, unequal variances\n\t            var u1 = v1/n1, u2 = v2/n2, u = u1 + u2;\n\t            var q1 = u1/u, q2 = u2/u; // u==0 must be invalidated\n\t            df = 1/(q1*q1/(n1-1) + q2*q2/(n2-1));\n\t            t_st =  f_abs(m1-m2)/Math.sqrt(u);\n\t            return tail == 1 ? Tdist_right(t_st, df) : Tdist_2tail(t_st, df);\n\t        }\n\t        else { // (type == 2) unpaired, equal variances (\"equal\" in the sense that there is no significant difference in variance in both groups - a prealable F-test could revealed that)\n\t            df = n1 + n2 - 2;\n\t            t_st = f_abs(m1-m2)*Math.sqrt(df*n1*n2/((n1+n2)*((n1-1)*v1+(n2-1)*v2)));\n\t            return tail == 1 ? Tdist_right(t_st, df) : Tdist_2tail(t_st, df);\n\t        }\n\t    }\n\n\t    function confidence_t(alpha, stddev, size) { // CONFIDENCE.T(alpha,standard_dev,size)\n\t        return -Tdist_inv(alpha/2, size-1)*stddev/Math.sqrt(size);\n\t    }\n\n\t    function confidence_norm(alpha, stddev, size) { // CONFIDENCE.NORM(alpha,standard_dev,size)\n\t        return -NORM_S_INV(alpha/2)*stddev/Math.sqrt(size);\n\t    }\n\n\t    function gauss(z) { // GAUSS(z)\n\t        return NORM_S_DIST(z, true) - 0.5;\n\t    }\n\n\t    function phi(x) { // PHI(x)\n\t        return NORM_S_DIST(x);\n\t    }\n\n\t    function lognorm_dist(x, m, s, cumulative) { // LOGNORM.DIST(x,mean,standard_dev,cumulative)\n\t        if (cumulative) {\n\t            return 0.5 + 0.5*ERF((Math.log(x)-m)/(s*Math.sqrt(2)));\n\t        }\n\t        var t = Math.log(x)-m;\n\t        return Math.exp(-t*t/(2*s*s))/(x*s*Math.sqrt(2*Math.PI));\n\t    }\n\n\t    function lognorm_inv(p, m, s) { //LOGNORM.INV(probability, mean, standard_dev)\n\t        return Math.exp(NORM_INV(p, m, s));\n\t    }\n\n\t    function prob(x_, p_, lw, up) { //PROB(x_range, prob_range, [lower_limit], [upper_limit])\n\t        var n = x_.length;\n\t        var s = 0, i;\n\t        for (i = 0; i < n; i++) {\n\t            if (p_[i] <= 0 || p_[i] > 1) {\n\t                throw new CalcError(\"NUM\");\n\t            }\n\t            s += p_[i];\n\t        }\n\t        if (s != 1) {\n\t            throw new CalcError(\"NUM\");\n\t        }\n\t        var res = 0;\n\t        for (i = 0; i < n; i++) {\n\t            var x = x_[i];\n\t            if (x >= lw && x <= up) {\n\t                res += p_[i];\n\t            }\n\t        }\n\t        return res;\n\t    }\n\n\t    function slope(y_, x_) { // SLOPE(known_y's, known_x's)\n\t        var mx = _mean(x_), my = _mean(y_), b1 = 0, b2 = 0;\n\t        for (var i = 0, n = y_.length; i < n; i++) {\n\t            var t = x_[i] - mx;\n\t            b1 += t*(y_[i] - my);\n\t            b2 += t*t;\n\t        }\n\t        return b1/b2;\n\t    }\n\n\t    function intercept(y_, x_) { // INTERCEPT(known_y's, known_x's)\n\t        var mx = _mean(x_), my = _mean(y_);\n\t        // return my - mx*slope(y_, x_);  //but repeating the calls for _mean()\n\t        var b1 = 0, b2 = 0;\n\t        for (var i = 0, n = y_.length; i < n; i++) {\n\t            var t = x_[i] - mx;\n\t            b1 += t*(y_[i] - my);\n\t            b2 += t*t;\n\t        }\n\t        return my - b1*mx/b2;\n\t    }\n\n\t    function pearson(x_, y_) { // PEARSON(array1, array2)\n\t        whipNumberArrays(x_, y_);\n\t        var mx = _mean(x_), my = _mean(y_);\n\t        var s1 = 0, s2 = 0, s3 = 0;\n\t        for(var i = 0, n = x_.length; i < n; i++) {\n\t            var t1 = x_[i] - mx, t2 = y_[i] - my;\n\t            s1 += t1*t2;\n\t            s2 += t1*t1;\n\t            s3 += t2*t2;\n\t        }\n\t        return s1/Math.sqrt(s2*s3);\n\t    }\n\n\t    function rsq(x_, y_) { // RSQ(known_y's,known_x's)\n\t        var r = pearson(x_, y_);\n\t        return r*r;\n\t    }\n\n\t    function steyx(y_, x_) { //STEYX(known_y's, known_x's)\n\t        var n = x_.length;\n\t        var mx = _mean(x_), my = _mean(y_);\n\t        var s1 = 0, s2 = 0, s3 = 0;\n\t        for (var i = 0; i < n; i++) {\n\t            var t1 = x_[i] - mx, t2 = y_[i] - my;\n\t            s1 += t2*t2;\n\t            s2 += t1*t2;\n\t            s3 += t1*t1;\n\t        }\n\t        return Math.sqrt((s1 - s2*s2/s3)/(n-2));\n\t    }\n\n\t    function forecast(x, y_, x_) { //FORECAST(x, known_y's, known_x's)\n\t        var mx = _mean(x_), my = _mean(y_);\n\t        var s1 = 0, s2 = 0;\n\t        for (var i = 0, n = x_.length; i < n; i++) {\n\t            var t1 = x_[i] - mx, t2 = y_[i] - my;\n\t            s1 += t1*t2;\n\t            s2 += t1*t1;\n\t        }\n\t        if (s2 === 0) {\n\t            throw new CalcError(\"N/A\");\n\t        }\n\t        var b = s1/s2, a = my - b*mx;\n\t        return a + b*x;\n\t    }\n\n\t    function _mat_mean(Mat) { // returns the mean value of a Matrix(n, 1)\n\t        var n = Mat.height, sum = 0;\n\t        for (var i=0; i < n; i++) {\n\t            sum += Mat.data[i][0];\n\t        }\n\t        return sum/n;\n\t    }\n\n\t    function _mat_devsq(Mat, mean) { // returns the sum of squares of deviations for a Matrix(n, 1)\n\t        var n = Mat.height, sq = 0;\n\t        for (var i=0; i < n; i++) {\n\t            var x = Mat.data[i][0] - mean;\n\t            sq += x*x;\n\t        }\n\t        return sq;\n\t    }\n\n\t    function linest(Y, X, konst, stats) { // LINEST(known_y's, [known_x's], [const], [stats])\n\t        var i = 0;\n\n\t        if (!X) {\n\t            // if not passed, X should default to array {1, 2, 3, ...} (same size as Y)\n\t            X = Y.map(function(){ return ++i; });\n\t        }\n\n\t        if (konst) { // adding 1's column is unnecessary when const==false (meaning that y_intercept==0)\n\t            X = X.clone();\n\t            X.eachRow(function(row){\n\t                X.data[row].unshift(1);\n\t            });\n\t            ++X.width;\n\t        }\n\n\t        var Xt = X.transpose();\n\t        var B = Xt.multiply(X).inverse().multiply(Xt).multiply(Y); // the last square estimate of the coefficients\n\t        var line_1 = [];\n\t        for (i = B.height-1; i >= 0; i--) {\n\t            line_1.push(B.data[i][0]); // regression coefficients ('slopes') and the y_intercept\n\t        }\n\t        if (!konst) {\n\t            line_1.push(0); // display 0 for y_intercept, when const==false\n\t        }\n\t        if (!stats) {\n\t            return this.asMatrix([ line_1 ]); // don't display statistics about the regression, when stats==false\n\t        }\n\n\t        var Y1 = X.multiply(B); // the predicted Y values\n\t        var y_y1 = Y.adds(Y1, true); // the errors of the predictions (= Y - Y1)\n\t        var mp = !konst? 0 : _mat_mean(Y1);\n\t        var SSreg = _mat_devsq(Y1, mp); // The regression sum of squares\n\t        var me = !konst? 0 : _mat_mean(y_y1);\n\t        var SSresid = _mat_devsq(y_y1, me); // The residual sum of squares\n\t        var line_5 = [];\n\t        line_5.push(SSreg, SSresid);\n\t        var R2 = SSreg / (SSreg + SSresid); // The coefficient of determination\n\t        var degfre = Y.height - X.width; // The degrees of freedom\n\t        var err_est = Math.sqrt(SSresid / degfre); // The standard error for the y estimate\n\t        var line_3 = [];\n\t        line_3.push(R2, err_est);\n\t        var F_sta = !konst ? (R2/X.width)/((1-R2)/(degfre)) : (SSreg/(X.width-1))/(SSresid/degfre); // The F statistic\n\t        var line_4 = [];\n\t        line_4.push(F_sta, degfre);\n\t        var SCP = Xt.multiply(X).inverse();\n\t        var line_2 = [];\n\t        for (i=SCP.height-1; i >= 0; i--) { // The standard errors (of coefficients an y-intercept)\n\t            line_2.push(Math.sqrt(SCP.data[i][i]*SSresid/degfre));\n\t        }\n\t        return this.asMatrix([line_1, line_2, line_3, line_4, line_5]);\n\t    }\n\n\t    function logest(Y, X, konst, stats) { // LOGEST(known_y's, [known_x's], [const], [stats])\n\t        return linest.call(this, Y.map(Math.log), X, konst, stats).map(Math.exp);\n\t    }\n\n\t    function trend(Y, X, W, konst) { // TREND(known_y's, [known_x's], [new_x's], [const])\n\t        var i = 0;\n\n\t        if (!X) {\n\t            // if not passed, X should default to array {1, 2, 3, ...} (same size as Y)\n\t            X = Y.map(function(){ return ++i; });\n\t        }\n\n\t        if (konst) { // adding 1's column is unnecessary when const==false (meaning that y_intercept==0)\n\t            X = X.clone();\n\t            X.eachRow(function(row){\n\t                X.data[row].unshift(1);\n\t            });\n\t            ++X.width;\n\t        }\n\n\t        var Xt = X.transpose();\n\t        var B = Xt.multiply(X).inverse().multiply(Xt).multiply(Y); // the last square estimate of the coefficients\n\n\t        if (!W) {\n\t            W = X;\n\t        } else {\n\t            if (konst) { // for non-zero y_intercept\n\t                W = W.clone();\n\t                W.eachRow(function(row){\n\t                    W.data[row].unshift(1);\n\t                });\n\t                ++W.width;\n\t            }\n\t        }\n\t        return W.multiply(B); // the predicted Y values for the W values\n\t    }\n\n\t    function growth(Y, X, new_X, konst) { // GROWTH(known_y's, [known_x's], [new_x's], [const])\n\t        // = EXP(TREND(LN(Y_), X_, new_X, const))\n\t        return trend.call(this, Y.map(Math.log), X, new_X, konst).map(Math.exp);\n\t    }\n\n\t    /*\n\t      [1] Handbook of Mathematical Functions (NIST, 1964-2010):\n\t      https://en.wikipedia.org/wiki/Abramowitz_and_Stegun\n\t      http://dlmf.nist.gov/\n\t      http://www.aip.de/groups/soe/local/numres/\n\n\t      [2] https://en.wikibooks.org/wiki/Statistics/Numerical_Methods/Numerics_in_Excel\n\t    */\n\n\t    /* -----[ financial functions ]----- */\n\n\t    //// find the root of a function known an initial guess (Newton's method) ////\n\t    function root_newton(func, guess, max_it, eps) { // func(x) must return [value_F(x), value_F'(x)]\n\t        var MAX_IT = max_it || 20, // maximum number of iterations\n\t            EPS = eps || 1E-7; // accuracy\n\t        var root = guess;\n\t        for (var j = 1; j <= MAX_IT; j++) {\n\t            var f_d = func(root),\n\t                f = f_d[0], // the value of the function\n\t                df = f_d[1]; // the value of the derivative\n\t            var dx = f / df;\n\t            root -= dx;\n\t            if (Math.abs(dx) < EPS) {\n\t                return root;\n\t            }\n\t        }\n\t        return new CalcError(\"NUM\");\n\t    }\n\n\n\t    /* https://support.office.com/en-us/article/PV-function-23879d31-0e02-4321-be01-da16e8168cbd\n\t       if(rate==0):\n\t       PMT * nper + PV + FV = 0\n\t       else: //the basic equation (with six variables) implied in financial problems\n\t       PV * (1+rate)^nper + PMT * (1+rate*type) * ((1+rate)^nper-1) / rate + FV = 0         [1]\n\t    */\n\n\n\n\t    //// FV (final or future value) ////\n\t    /* I initially invest £1000 in a saving scheme and then at the end of each month I invest an\n\t       extra £50. If the interest rate is 0.5% per month and I continue this process for two year,\n\t       how much will my saving be worth: =FV(0.005, 24, -50, -1000, 0) */\n\t    function FV(rate, nper, pmt, pv, type) { // FV(rate,nper,pmt,[pv],[type])\n\t        var h1 = Math.pow(1+rate, nper);\n\t        var h2 = rate ? (h1 - 1)/rate : nper;\n\t        return -(pv * h1 + pmt * h2 * (1 + rate*type));\n\t    }\n\n\t    //// PV (present value of investment) ////\n\t    /* If I wish to accumulate £5000 in four years time by depositing £75 per month in a fixed\n\t       rate account with interest rate of 0.4% per month, what initial investment must I also\n\t       make: =PV(0.004, 4*12, -75, 5000, 0) */\n\t    function PV(rate, nper, pmt, fv, type) { // PV(rate, nper, pmt, [fv], [type])\n\t        if (!rate) {\n\t            return -fv - pmt*nper;\n\t        }\n\t        var h1 = Math.pow(1+rate, nper);\n\t        return -(fv + pmt * (h1 - 1)/rate * (1 + rate*type)) / h1;\n\t    }\n\n\t    //// PMT monthly payments (= principal part PPMT + interest part IPMT) ////\n\t    /* How much will the monthly repayments be if I borrow £100,000 over 20 years with an\n\t       effective monthly interest rate is 0.5%: =PMT(0.005, 12*20, 100000, 0, 0) */\n\t    function PMT(rate, nper, pv, fv, type) { // PMT(rate, nper, pv, [fv], [type])\n\t        if (!rate) {\n\t            return -(fv + pv)/nper;\n\t        }\n\t        var h1 = Math.pow(1+rate, nper);\n\t        return -rate*(fv + pv*h1)/((1 + rate*type)*(h1 - 1));\n\t    }\n\n\t    //// NPER (number of periods for an investment) ////\n\t    /* How long would it take me to pay off a loan of £10,000 at a rate of 0.5% per month if I\n\t       can afford to pay £100 per month: =NPER(0.5%, -100, 10000, 0, 0) */\n\t    function NPER(rate, pmt, pv, fv, type) { // NPER(rate,pmt,pv,[fv],[type])\n\t        if (!rate) {\n\t            return -(fv + pv) / pmt;\n\t        }\n\t        var h1 = pmt*(1 + rate*type);\n\t        return Math.log((h1 - fv*rate)/(h1 + pv*rate)) / Math.log(1 + rate);\n\t    }\n\n\t    //// RATE (the interest rate per period) ////\n\t    /* I borrow £1000 over 1 year making payments of £100 per month at the end of each\n\t       month. What is the monthly interest rate: =RATE(12, −100, 1000, 0, 0, 0) */\n\n\t    function RATE (nper, pmt, pv, fv, type, guess) { // RATE(nper, pmt, pv, [fv], [type], [guess])\n\t        function xfd(x) { // returns F(x) and F'(x), where F is given by the equation [1]\n\t            var h2 = Math.pow(1+x, nper-1), h1 = h2*(1+x);\n\t            return [ pv*h1 + pmt*(1/x + type)*(h1 - 1) + fv,\n\t                     nper*pv*h2 + pmt*(-(h1 - 1)/(x*x) + (1/x + type)*nper*h2) ];\n\t        }\n\t        return root_newton(xfd, guess); // a root of the equation F(x)=0\n\t    }\n\n\t    //// IPMT (interest part of a loan or investment) ////\n\t    //// PPMT (principal part of a loan) ////\n\n\t    function IPMT(rate, per, nper, pv, fv, type) { // IPMT(rate, per, nper, pv, [fv], [type])\n\t        if(type==1 && per==1) { // interest before beginnig of the payments... = ZERO\n\t            return 0;\n\t        }\n\t        var pmt = PMT(rate, nper, pv, fv, type);\n\t        var ipmt = FV(rate, per - 1, pmt, pv, type) * rate;\n\t        return type ? ipmt/(1 + rate) : ipmt;\n\t    }\n\n\t    function PPMT(rate, per, nper, pv, fv, type) { // PPMT(rate, per, nper, pv, [fv], [type])\n\t        var pmt = PMT(rate, nper, pv, fv, type);\n\t        return pmt - IPMT(rate, per, nper, pv, fv, type);\n\t    }\n\n\t    //// CUMPRINC (cumulative principal paid) ////\n\t    /* The amount financed is $200,000 at an interest rate of 7.25% for 30 years. How much is the amount of principal\n\t       and the amount of interest paid in the first year: CUMPRINC(0.0725/12, 12*30, 200000, 1, 12, 0)\n\t       and CUMIPMT(0.0725/12, 12*30, 200000, 1, 12, 0) */\n\t    function CUMPRINC(rate, nper, pv, start, end, type) { // CUMPRINC(rate, nper, pv, start_period, end_period, type)\n\t        if(type == 1) { // start >= 1 (as in Excel), but if pay at beginning of the period (type==1),\n\t            start --;    // then periods must be counted from Zero (decreasing given start and end parameters)\n\t            end --;\n\t        }\n\t        var tn = Math.pow(1 + rate, nper),\n\t            ts = Math.pow(1 + rate, start-1),\n\t            te = Math.pow(1 + rate, end);\n\t        var monthlyPayment = rate * pv * tn / (tn - 1);\n\t        var remainingBalanceAtStart = ts * pv - ((ts - 1) / rate) * monthlyPayment;\n\t        var remainingBalanceAtEnd = te * pv - ((te - 1) / rate) * monthlyPayment;\n\t        return remainingBalanceAtEnd - remainingBalanceAtStart;\n\t    }\n\n\t    //// CUMIPMT (cumulative  interest paid) ////\n\t    function CUMIPMT(rate, nper, pv, start, end, type) { // CUMIPMT(rate, nper, pv, start_period, end_period, type)\n\t        var cip = 0;\n\t        for(var i=start; i<=end; i++) {\n\t            cip += IPMT(rate, i, nper, pv, 0, type);\n\t        }\n\t        return cip;\n\t    }\n\n\t    //// NPV (Net Present Value of an investment based on a series of periodic cash flows and a discount rate) ////\n\t    function NPV(rate, flows) { // NPV(rate,value1,[value2],...)\n\t        var npv = 0;\n\t        for(var i=0, n=flows.length; i < n; i++) {\n\t            npv += flows[i]*Math.pow(1 + rate, -i-1);\n\t        }\n\t        return npv;\n\t    }\n\n\t    //// IRR (Internal Rate of Return on an investment based on a series of periodic cash flows) ////\n\t    function IRR(flows, guess) { // IRR(values, [guess])\n\t        function xfd(x) {\n\t            var npv = 0, npv1 = 0;\n\t            for(var j=0, n=flows.length; j < n; j++) {\n\t                npv += flows[j]*Math.pow(1 + x, -j-1); // construct the NPV(x) value,\n\t                npv1 += -j*flows[j]*Math.pow(1+x, -j-2); // the value in x of the NPV()-derivative\n\t            }\n\t            return [npv, npv1];\n\t        }\n\t        return root_newton(xfd, guess);\n\t    }\n\n\t    //// EFFECT (effective annual interest rate) ////\n\t    /* which investment option is better - one that pays 5 percent after one year, or a\n\t       savings account that pays a monthly interest of 4.75 percent:\n\t       = (5% - EFFECT(4.75%, 12)) * 10000 */\n\t    function EFFECT(nominal_rate, npery) { // EFFECT(nominal_rate, npery)\n\t        return Math.pow(1 + nominal_rate/npery, npery) - 1;\n\t    }\n\n\t    //// NOMINAL (nominal annual interest rate) ////\n\t    function NOMINAL(effect_rate, npery) { // NOMINAL(effect_rate, npery)\n\t        return npery*(Math.pow(effect_rate + 1, 1/npery) - 1);\n\t    }\n\n\t    //// XNPV (Net Present Value of a series of cashflows at irregular intervals) ////\n\t    function XNPV(rate, values, dates) { // XNPV(rate, values, dates)\n\t        var npv = 0;\n\t        for(var i=0, n=values.length; i < n; i++) {\n\t            npv += values[i]*Math.pow(1 + rate, (dates[0]-dates[i])/365);\n\t        }\n\t        return npv;\n\t    }\n\n\t    //// XIRR (Internal Rate of Return of a series of cashflows at irregular intervals) ////\n\t    function XIRR(values, dates, guess) { // XIRR(values, dates, [guess])\n\t        function xfd(x) {\n\t            var npv = values[0], npv1 = 0;\n\t            for(var j=1, n=values.length; j < n; j++) {\n\t                var delta = (dates[0] - dates[j]) / 365;\n\t                npv += values[j]*Math.pow(1 + x, delta); // construct the XNPV(x) value,\n\t                npv1 += delta*values[j]*Math.pow(1+x, delta - 1); // the value in x of the XNPV()-derivative\n\t            }\n\t            return [npv, npv1];\n\t        }\n\t        return root_newton(xfd, guess); // , 100, 0.1);\n\t    }\n\n\t    //// ISPMT (Interest paid during a Specific Period of an investment) ////\n\t    function ISPMT(rate, per, nper, pv) { // ISPMT(rate, per, nper, pv)\n\t        var tmp = -pv*rate;\n\t        return tmp*(1 - per/nper);\n\t    }\n\n\t    //// DB (Declining Balance depreciation) ////\n\t    function DB(cost, salvage, life, period, month) { // DB(cost, salvage, life, period, [month])\n\t        var rate = 1 - Math.pow(salvage/cost, 1/life);\n\t        rate = Math.floor(rate*1000 + 0.5) / 1000; // rounded to three decimals\n\t        var db = cost * rate * month / 12;\n\t        if(period == 1) {\n\t            return db;\n\t        }\n\t        for(var i=1; i < life; i++) {\n\t            if(i == period - 1) {\n\t                return (cost - db) * rate;\n\t            }\n\t            db += (cost - db) * rate;\n\t        }\n\t        return (cost - db) * rate * (12 - month) / 12;\n\t    }\n\n\t    //// DDB (Double Declining Balance depreciation) ////\n\t    function DDB(cost, salvage, life, period, factor) { // DDB(cost, salvage, life, period, [factor])\n\t        var f = factor / life;\n\t        var prior = -cost * (Math.pow(1-f, period-1) - 1);\n\t        var dep = (cost - prior) * f;\n\t        /* Depreciation cannot exceed book value.  */\n\t        dep = Math.min(dep, Math.max(0, cost - prior - salvage));\n\t        return dep;\n\t    }\n\n\t    //// SLN (straight-line depreciation) ////\n\t    function SLN(cost, salvage, life) { // SLN(cost, salvage, life)\n\t        return (cost - salvage) / life;\n\t    }\n\n\t    //// SYD (Sum-of-Years' digits Depreciation) ////\n\t    function SYD(cost, salvage, life, per) { // SYD(cost, salvage, life, per)\n\t        return (cost - salvage) * (life - per + 1) * 2 / (life * (life + 1));\n\t    }\n\n\t    //// VDB (Variable Declining Balance) ////\n\t    //\n\t    // Code adapted from Gnumeric, which in turn took it from OpenOffice.  The original code is\n\t    // available under GNU Lesser General Public License (LGPL).\n\t    // https://github.com/GNOME/gnumeric/blob/master/plugins/fn-financial/sc-fin.c\n\t    function VDB (cost, salvage, life, start, end, factor, no_switch) {\n\t        var interest = factor >= life ? 1 : factor / life;\n\n\t        function _getGDA(value, period) {\n\t            var gda, oldValue, newValue;\n\t            if (interest == 1) {\n\t                oldValue = period == 1 ? value : 0;\n\t            } else {\n\t                oldValue = value * Math.pow(1 - interest, period - 1);\n\t            }\n\t            newValue = value * Math.pow(1 - interest, period);\n\t            gda = newValue < salvage ? oldValue - salvage : oldValue - newValue;\n\t            return gda < 0 ? 0 : gda;\n\t        }\n\n\t        function _interVDB(cost, life1, period) {\n\t            var remValue = cost - salvage;\n\t            var intEnd = Math.ceil(period);\n\t            var term, lia = 0, vdb = 0, nowLia = false;\n\t            for (var i = 1; i <= intEnd; i++) {\n\t                if (!nowLia) {\n\t                    var gda = _getGDA(cost, i);\n\t                    lia = remValue / (life1 - i + 1);\n\t                    if (lia > gda) {\n\t                        term = lia;\n\t                        nowLia = true;\n\t                    } else {\n\t                        term = gda;\n\t                        remValue -= gda;\n\t                    }\n\t                } else {\n\t                    term = lia;\n\t                }\n\t                if (i == intEnd) {\n\t                    term *= period + 1 - intEnd;\n\t                }\n\t                vdb += term;\n\t            }\n\t            return vdb;\n\t        }\n\n\t        var intStart = Math.floor(start), intEnd = Math.ceil(end);\n\t        var vdb = 0;\n\t        if (no_switch) {\n\t            for (var i = intStart + 1; i <= intEnd; i++) {\n\t                var term = _getGDA(cost, i);\n\t                if (i == intStart + 1) {\n\t                    term *= Math.min(end, intStart + 1) - start;\n\t                } else {\n\t                    if (i == intEnd) {\n\t                        term *= end + 1 - intEnd;\n\t                    }\n\t                }\n\t                vdb += term;\n\t            }\n\t        } else {\n\t            var life1 = life;\n\t            if (start != Math.floor(start)) {\n\t                if (factor > 1) {\n\t                    if (start >= life / 2) {\n\t                        var part = start - life / 2;\n\t                        start = life / 2;\n\t                        end -= part;\n\t                        life1 += 1;\n\t                    }\n\t                }\n\t            }\n\t            cost -= _interVDB(cost, life1, start);\n\t            vdb = _interVDB(cost, life - start, end - start);\n\t        }\n\t        return vdb;\n\t    }\n\n\t    /*************************************************************************************/\n\n\t    /*   (from  http://beginnersinvest.about.com)\n\t         an investor agrees to loan money to a company or government in exchange for a predetermined interest rate for a pre-determined length of time.\n\n\t         If an investor wanted to buy a $25,000 Coca-Cola bond with a 30 year maturity and an 10% coupon, it would work like this: He would send in the $25,000 from his savings account and get a $25,000 engraved bond certificate in exchange. After 30 years, he would be able to get his whole $25,000 back from the Coca-Cola company (of course, he can always sell it before then if he needs the money).\n\n\t         Every year, he’s entitled to receive 10% interest on the money he lent, or $2,500. Since most companies in the United States pay interest semi-annually, he would likely have 60 coupons attached to his bond for $1,250 each.\n\t         Every June 30th and December 31st, the investor would go down, clip the proper coupon, send it in, and get their money.\n\n\t         Although the practice is now defunct, the terminology stuck and interest payments on bonds will forever be known as coupons.\n\t    */\n\n\n\t    // \"Use EDATE to calculate maturity dates or due dates that fall on the same day of the month as the date of issue.\"\n\t    // See also: DATEDIF, DAY, DAYS, DAY360, EOMONTH (wich can be useful to determine limits of coupon periods)\n\t    function _edate(base, months) { // EDATE(start_date, months)\n\t        var d = unpackDate(base);\n\t        var m = d.month + months;\n\t        var y = d.year + Math.floor(m/12);\n\t        m %= 12;\n\t        if (m < 0) {\n\t            m += 12;\n\t        }\n\t        d = Math.min(d.date, daysInMonth(y, m));\n\t        return packDate(y, m, d);\n\t    }\n\n\t    function _daysBetween(from, to, basis) {\n\t        if (basis == 1 || basis == 2 || basis == 3) { // Actual/Actual || Actual/360 || Actual/365\n\t            return to - from;\n\t        }\n\t        return _days_360(from, to, basis);\n\t    }\n\n\t    // Find coupon dates that enclose the settlement date, counting backward from the maturity date.\n\t    /* independent of the 'basis' convention to count days - here we have no need to count days */\n\t    function _borderCoupons(settlement, maturity, freq) {\n\t        var sett = unpackDate(settlement), base = unpackDate(maturity);\n\t        var periods = base.year - sett.year;\n\t        if (periods > 0) {\n\t            periods = (periods - 1) * freq;\n\t        }\n\t        var prev, next, months = 12/freq;\n\t        do {\n\t            periods++;\n\t            prev = _edate(maturity, - periods*months);\n\t        } while (settlement < prev);\n\t        periods--;\n\t        next = _edate(maturity, - periods*months);\n\t        return [ prev, next ];\n\t    }\n\n\t    // Find coupon dates that enclose the settlement date, counting forward from the first-coupon payment.\n\t    /* independent of the 'basis' convention to count days - here we have no need to count days */\n\t    function _borderCoupons_fw(first, settlement, freq) {\n\t        var sett = unpackDate(settlement), base = unpackDate(first);\n\t        var periods = sett.year - base.year;\n\t        if (periods > 0) {\n\t            periods = (periods - 1) * freq;\n\t        }\n\t        var prev = first, next, months = 12/freq;\n\t        while (settlement > prev) {\n\t            next = prev;\n\t            periods++;\n\t            prev = _edate(first, periods*months);\n\t        }\n\t        return [ next, prev ];\n\t    }\n\n\t    //// COUPDAYBS (COUPon DAYs Beginning to Settlement) ////\n\t    /* returns the number of days from the beginning of the coupon period to the settlement date */\n\t    function COUPDAYBS(settlement, maturity, frequency, basis) { // COUPDAYBS(settlement, maturity, frequency, [basis])\n\t        var prev = _borderCoupons(settlement, maturity, frequency)[0];\n\t        return _daysBetween(prev, settlement, basis);\n\t    }\n\n\t    //// COUPDAYS (COUPon DAYs containing Settlement) ////\n\t    /* Returns the number of days in the coupon period that contains the settlement date */\n\t    function COUPDAYS(settl, matur, freq, basis) { // COUPDAYS(settlement, maturity, frequency, [basis])\n\t        if (basis == 1) {\n\t            var borders = _borderCoupons(settl, matur, freq);\n\t            return _daysBetween(borders[0], borders[1], 1);\n\t        }\n\t        if (basis == 3) {\n\t            return 365/freq;\n\t        }\n\t        return 360/freq;\n\t    }\n\n\t    //// COUPDAYSNC (COUPon DAYs Settlement to Next Coupon) ////\n\t    /* Returns the number of days from the settlement date to the next coupon date */\n\t    function COUPDAYSNC(settl, matur, freq, basis) { // COUPDAYSNC(settlement, maturity, frequency, [basis])\n\t        var next = _borderCoupons(settl, matur, freq)[1];\n\t        return _daysBetween(settl, next, basis);\n\t    }\n\n\t    //// COUPPCD (COUPon, Previous Coupon Date) ////\n\t    /* Returns the previous coupon date before the settlement date */\n\t    function COUPPCD(settl, matur, freq/*, basis*/) { // COUPPCD(settlement, maturity, frequency, [basis])\n\t        // It is no need to count days, so 'basis' becomes a inutil parameter.\n\t        return _borderCoupons(settl, matur, freq)[0];\n\t    }\n\n\t    //// COUPNCD (COUPon, Next Coupon Date) ////\n\t    /* Returns the next coupon date after the settlement date */\n\t    function COUPNCD(settl, matur, freq/*, basis*/) { // COUPNCD(settlement, maturity, frequency, [basis])\n\t        // It is no need to count days, so 'basis' becomes a inutil parameter.\n\t        return _borderCoupons(settl, matur, freq)[1];\n\t    }\n\n\t    function COUPNUM(settl, matur, freq/*, basis*/) { // COUPNUM(settlement, maturity, frequency, [basis])\n\t        var sett = unpackDate(settl),\n\t            mat = unpackDate(matur);\n\t        var months = 12*(mat.year - sett.year) + mat.month - sett.month;\n\t        //// Discount the last month if there are not enough days? Finally - we decide to not discount.\n\t        //// (if this \"last month\" have 2 days, Excel.COUPNUM returns 6 but GoogleSpreads give only 5)\n\t        //    var res = _edate(matur, -months);\n\t        //    if (sett.date >= unpackDate(res).date) {\n\t        //        months--; // an incomplete last month correspond to a qvasi-coupon period\n\t        //    }\n\t        return 1 + (months * freq / 12 | 0);\n\t    }\n\n\t    function daysInYear(yr, basis) {\n\t        if (basis == 3) { return 365; }\n\t        if (basis == 1) { return isLeapYear(yr) ? 366 : 365; }\n\t        return 360;\n\t    }\n\n\t    //// ACCRINTM  the accrued interest for a security that pays interest at maturity ////\n\t    function ACCRINTM(issue, maturity, rate, par, basis) { // ACCRINTM(issue, settlement, rate, par, [basis])\n\t        var year_days = daysInYear(unpackDate(maturity).year, basis); // 360;\n\t        return rate*par * _daysBetween(issue, maturity, basis) / year_days;\n\t    }\n\n\t    function ACCRINT(issue, first, settl, rate, par, freq, basis, calc) {\n\t        var accr = 0, cost = par * rate / freq;\n\t        var brace, prev, next, prev1, next1, nrc;\n\n\t        var annual = basis % 2 === 0 ? 360 : 365; // only if to >> from, we eventually need to count leap years\n\t        function _numCoupons(from, to) { // better than COUPNUM(from, to, freq, basis)-1\n\t            return (to - from)*freq/annual | 0;\n\t        }\n\n\t        if (settl <= first) {\n\t            brace = _borderCoupons(settl, first, freq);\n\t            prev = brace[0];\n\t            next = brace[1];\n\t            if (prev <= issue) {\n\t                return cost * _daysBetween(issue, settl, basis) / _daysBetween(prev, next, basis);\n\t            }\n\t            brace = _borderCoupons(issue, prev, freq);\n\t            prev1 = brace[0];\n\t            next1 = brace[1];\n\t            nrc = _numCoupons(next1, settl); // when settl==next, days are counted implicitly by nrc\n\t            return cost *\n\t                (nrc +\n\t                 _daysBetween(issue, next1, basis) / _daysBetween(prev1, next1, basis) +\n\t                 (settl < next? _daysBetween(prev, settl, basis) / _daysBetween(prev, next, basis) : 0));\n\t        } else {\n\t            brace = _borderCoupons_fw(first, settl, freq);\n\t            prev = brace[0];\n\t            next = brace[1];\n\t            nrc = _numCoupons(first, settl); // COUPNUM(first, settl, freq, basis) - 1;\n\t            if (next == settl) {\n\t                accr = cost * nrc;\n\t            } else {\n\t                accr = cost * (nrc + _daysBetween(prev, settl, basis) / _daysBetween(prev, next, basis));\n\t            }\n\t            if (!calc) { return accr; } // Only the accrued interest between first and settlement dates.\n\t            brace = _borderCoupons(issue, first, freq); // Add the accrued interest between issue and first dates.\n\t            prev = brace[0];\n\t            next = brace[1];\n\t            nrc = _numCoupons(issue, first);\n\t            accr += cost * (nrc + _daysBetween(issue, next, basis) / _daysBetween(prev, next, basis));\n\t            return accr; // accrued interest between issue and settlement dates\n\t        }\n\t    }\n\n\t    //// DISC  the discount rate for a security (given price and redemption values per 100$ face value) ////\n\t    function DISC(settl, matur, pr, redemption, basis) { // DISC(settlement, maturity, pr, redemption, [basis])\n\t        var annual = basis % 2 === 0 ? 360 : (isLeapYear(unpackDate(settl).year) ? 366 : 365);\n\t        return (redemption - pr)/redemption*annual/_daysBetween(settl, matur, basis);\n\t    }\n\n\t    //// INTRATE  the interest rate for a fully invested security ////\n\t    function INTRATE(settl, matur, investment, redemption, basis) { // INTRATE(settlement, maturity, investment, redemption, [basis])\n\t        var annual = basis % 2 === 0 ? 360 : (isLeapYear(unpackDate(settl).year) ? 366 : 365);\n\t        return (redemption - investment)/investment*annual/_daysBetween(settl, matur, basis);\n\t    }\n\n\t    //// RECEIVED  the amount received at maturity for a fully invested security ////\n\t    function RECEIVED(settl, matur, investment, discount, basis) { // RECEIVED(settlement, maturity, investment, discount, [basis])\n\t        var annual = basis % 2 === 0 ? 360 : (isLeapYear(unpackDate(settl).year) ? 366 : 365);\n\t        return investment/(1 - discount*_daysBetween(settl, matur, basis)/annual);\n\t    }\n\n\t    //// PRICE  the price per $100 face value of a security that pays periodic interest ////\n\t    function PRICE(settl, matur, rate, yld, redemption, freq, basis) { // PRICE(settlement, maturity, rate, yld, redemption, frequency, [basis])\n\t        var N = 1 + ((matur - settl)*freq/(basis % 2 === 0 ? 360 : 365) | 0); // coupons playable between settlement and maturity dates\n\t        var brace = _borderCoupons(settl, matur, freq),\n\t            prev = brace[0], next = brace[1];\n\t        var beg_settl = _daysBetween(prev, settl, basis),\n\t            settl_end = _daysBetween(settl, next, basis),\n\t            beg_end = _daysBetween(prev, next, basis);\n\t        var den = 100*rate/freq,\n\t            yf = yld/freq,\n\t            frac = settl_end / beg_end;\n\t        if (N == 1) {\n\t            return (redemption + den)/(1 + frac*yf) - beg_settl / beg_end * den;\n\t        }\n\t        return redemption / Math.pow(1 + yf, N-1+frac)\n\t            + den * Math.pow(1 + yf, 1-N-frac) * (Math.pow(1+yf, N) - 1) / yf\n\t            - beg_settl / beg_end * den;\n\t    }\n\n\t    //// PRICEDISC  the price per $100 face value of a discounted security ////\n\t    function PRICEDISC(settl, matur, discount, redemption, basis) { // PRICEDISC(settlement, maturity, discount, redemption, [basis])\n\t        var dsm = _daysBetween(settl, matur, basis),\n\t            dy = daysInYear(unpackDate(matur).year, basis);\n\t        return redemption - discount*redemption*dsm/dy;\n\t    }\n\n\t    // Used in PEARSON, more could follow.  In some situations Excel appears to silently ignore\n\t    // missing or non-numeric values, for example if some value in a is missing a corresponding\n\t    // value in b, then the one in a is going to be ignored as if not present.  Arrays must have the\n\t    // same number of elements.  I couldn't come up with a good name for this function.\n\t    function whipNumberArrays(a, b) {\n\t        for (var i = a.length; --i >= 0;) {\n\t            if (typeof a[i] != \"number\" || typeof b[i] != \"number\") {\n\t                a.splice(i, 1);\n\t                b.splice(i, 1);\n\t            }\n\t        }\n\t    }\n\n\t}, __webpack_require__(3));\n\n\n/***/ })\n\n/******/ });","module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ (function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(1670);\n\tmodule.exports = __webpack_require__(1670);\n\n\n/***/ }),\n\n/***/ 3:\n/***/ (function(module, exports) {\n\n\tmodule.exports = function() { throw new Error(\"define cannot be used indirect\"); };\r\n\n\n/***/ }),\n\n/***/ 1656:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"./references\");\n\n/***/ }),\n\n/***/ 1670:\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// -*- fill-column: 100 -*-\n\n\t(function(f, define){\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ __webpack_require__(1656) ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t})(function(){\n\t    \"use strict\";\n\n\t    // WARNING: removing the following jshint declaration and turning\n\t    // == into === to make JSHint happy will break functionality.\n\t    /* jshint eqnull:true, newcap:false, laxbreak:true, shadow:true, validthis:true, -W054, loopfunc: true */\n\t    /* global console */\n\t    /* jshint latedef: nofunc */\n\n\t    var calc = {};\n\t    var spreadsheet = kendo.spreadsheet;\n\t    spreadsheet.calc = calc;\n\t    var exports = calc.runtime = {};\n\t    var Class = kendo.Class;\n\n\t    var Ref = spreadsheet.Ref;\n\t    var CellRef = spreadsheet.CellRef;\n\t    var RangeRef = spreadsheet.RangeRef;\n\t    var UnionRef = spreadsheet.UnionRef;\n\t    var NULL = spreadsheet.NULLREF;\n\n\t    /* -----[ Errors ]----- */\n\n\t    function CalcError(code) {\n\t        if (code instanceof CalcError) {\n\t            return code;\n\t        }\n\t        this.code = code;\n\t    }\n\n\t    CalcError.prototype.toString = function() {\n\t        return \"#\" + this.code + (this.code == \"NAME\" ? \"?\" : \"!\");\n\t    };\n\n\t    /* -----[ Context ]----- */\n\n\t    var Context = Class.extend({\n\t        init: function Context(callback, formula, ss, parent) {\n\t            this.callback = callback;\n\t            this.formula = formula;\n\t            this.ss = ss;\n\t            this.parent = parent;\n\t        },\n\n\t        resolve: function(val) {\n\t            var self = this;\n\t            if (val instanceof Ref) {\n\t                self.resolveCells([ val ], function(){\n\t                    self._resolve(val);\n\t                });\n\t            } else {\n\t                self._resolve(val);\n\t            }\n\t        },\n\n\t        error: function(val) {\n\t            return new CalcError(val);\n\t        },\n\n\t        _resolve: function(val) {\n\t            if (val === undefined) {\n\t                val = null;\n\t            } else if (Array.isArray(val)) {\n\t                val = this.asMatrix(val);\n\t            } else {\n\t                val = maybeRoundFloatErrors(val);\n\t            }\n\t            var f = this.formula;\n\t            if (f.arrayFormulaRange) {\n\t                // when this is an array formula, make sure we return a Matrix.  The value already\n\t                // *should* be a Matrix, so this won't incur speed penalty in normal cases.\n\t                val = this.asMatrix(val) || this.asMatrix([[ val ]]);\n\t            } else if (val instanceof RangeRef) {\n\t                val = this._arrayArg(val);\n\t            }\n\t            f.value = val;\n\t            if (this.ss.onFormula(f) && this.callback) {\n\t                this.callback.call(f, val);\n\t            }\n\t        },\n\n\t        resolveCells: function(a, f) {\n\t            var context = this, formulas = [];\n\n\t            (function loop(a){\n\t                for (var i = 0; i < a.length; ++i) {\n\t                    var x = a[i];\n\t                    if (x instanceof Ref) {\n\t                        add(context.getRefCells(x));\n\t                    }\n\t                    if (Array.isArray(x)) {\n\t                        // make sure we resolve cells in literal matrices\n\t                        loop(x);\n\t                    }\n\t                }\n\t            })(a);\n\n\t            if (!formulas.length) {\n\t                return f.call(context);\n\t            }\n\n\t            for (var pending = formulas.length, i = 0; i < formulas.length; ++i) {\n\t                fetch(formulas[i]);\n\t            }\n\t            function fetch(formula) { // jshint ignore:line, because you are stupid.\n\t                formula.exec(context.ss, function(){\n\t                    if (!--pending) {\n\t                        f.call(context);\n\t                    }\n\t                }, context);\n\t            }\n\t            function add(a) {\n\t                for (var i = 0; i < a.length; ++i) {\n\t                    var cell = a[i];\n\t                    if (cell.formula) {\n\t                        formulas.push(cell.formula);\n\t                    }\n\t                }\n\t                return true;\n\t            }\n\t        },\n\n\t        cellValues: function(a, wantNulls) {\n\t            var ret = [];\n\t            for (var i = 0; i < a.length; ++i) {\n\t                var val = a[i];\n\t                if (val instanceof Ref) {\n\t                    val = this.getRefData(val, wantNulls);\n\t                    ret = ret.concat(val);\n\t                } else if (Array.isArray(val)) {\n\t                    ret = ret.concat(this.cellValues(val, wantNulls));\n\t                } else if (val instanceof Matrix) {\n\t                    ret = ret.concat(this.cellValues(val.data, wantNulls));\n\t                } else {\n\t                    ret.push(val);\n\t                }\n\t            }\n\t            return ret;\n\t        },\n\n\t        fetchName: function(ref, callback) {\n\t            var f = this.formula;\n\t            var val = this.ss.nameValue(ref, f.sheet, f.row, f.col);\n\t            if (val instanceof Formula) {\n\t                // clone and relocate to calling formula, so that relative references in a named\n\t                // formula would work as expected.\n\t                val = val.clone(f.sheet, f.row, f.col, true);\n\n\t                // XXX: I don't like this dependency here; basically we only need ss.onFormula to\n\t                // return true and do nothing else.\n\t                var ss = new spreadsheet.ValidationFormulaContext(this.ss.workbook);\n\n\t                val.exec(ss, callback, this);\n\t            } else {\n\t                if (val instanceof Ref) {\n\t                    // relocate for relative refs\n\t                    val = val.absolute(f.row, f.col);\n\t                    if (val instanceof RangeRef && this.ss.isMerged(val)) {\n\t                        val = val.topLeft;\n\t                    }\n\t                    if (!val.sheet) {\n\t                        val.sheet = f.sheet;\n\t                    }\n\t                }\n\t                callback(val == null ? new CalcError(\"NAME\") : val);\n\t            }\n\t        },\n\n\t        force: function(val) {\n\t            if (val instanceof Ref) {\n\t                return this.getRefData(val);\n\t            }\n\t            return val;\n\t        },\n\n\t        func: function(fname, callback, args) {\n\t            fname = fname.toLowerCase();\n\t            var f = FUNCS[fname];\n\t            if (f) {\n\t                return f.call(this, callback, args);\n\t            }\n\t            callback(new CalcError(\"NAME\"));\n\t        },\n\n\t        bool: function(val) {\n\t            if (val instanceof Ref) {\n\t                val = this.getRefData(val);\n\t            }\n\t            if (typeof val == \"string\") {\n\t                return val.toLowerCase() == \"true\";\n\t            }\n\t            if (typeof val == \"number\") {\n\t                return val !== 0;\n\t            }\n\t            if (typeof val == \"boolean\") {\n\t                return val;\n\t            }\n\t            return val != null;\n\t        },\n\n\t        _arrayArg: function(ref) { // not necessarily a reference though\n\t            var f = this.formula;\n\t            if (!f.arrayFormulaRange && ref instanceof RangeRef) {\n\t                // if formula wasn't saved with Ctrl-Shift-Enter but a range is passed, Excel does\n\t                // something special:\n\t                //\n\t                // - if range is Wx1 (horizontal array) and current formula resides within the\n\t                //   horizontal bounds of the range, the appropriate cell is selected.  Example:\n\t                //   A1..D1 contain 1, 2, 3, 4 and we have in B2: =A1:D1, then B2 will get 2 (the\n\t                //   value in A2).  If the same formula is typed outside the horizontal span of the\n\t                //   range, say in E2: =A1:D1, then #VALUE! is returned.\n\t                //\n\t                // - similarly, if the range is 1xH (vertical array), the formula must reside within\n\t                //   the vertical bounds of the range and it gets the corresponding cell; otherwise,\n\t                //   #VALUE!.\n\t                if (ref.height() == 1 && f.col >= ref.topLeft.col && f.col <= ref.bottomRight.col) {\n\t                    return this.getRefData(new CellRef(ref.topLeft.row, f.col).setSheet(ref.sheet));\n\t                }\n\t                if (ref.width() == 1 && f.row >= ref.topLeft.row && f.row <= ref.bottomRight.row) {\n\t                    return this.getRefData(new CellRef(f.row, ref.topLeft.col).setSheet(ref.sheet));\n\t                }\n\t                return new CalcError(\"VALUE\");\n\t            } else {\n\t                return this.asMatrix(ref);\n\t            }\n\t        },\n\n\t        asMatrix: function(range) {\n\t            if (range instanceof Matrix) {\n\t                return range;\n\t            }\n\t            var self = this;\n\t            if (range instanceof RangeRef) {\n\t                var tl = range.topLeft;\n\t                var top = tl.row, left = tl.col;\n\t                var cells = self.getRefCells(range);\n\t                var m = new Matrix(self);\n\t                if (isFinite(range.width())) {\n\t                    m.width = range.width();\n\t                }\n\t                if (isFinite(range.height())) {\n\t                    m.height = range.height();\n\t                }\n\t                if (!isFinite(top)) {\n\t                    top = 0;\n\t                }\n\t                if (!isFinite(left)) {\n\t                    left = 0;\n\t                }\n\t                cells.forEach(function(cell){\n\t                    m.set(cell.row - top,\n\t                          cell.col - left,\n\t                          cell.value);\n\t                });\n\t                return m;\n\t            }\n\t            if (Array.isArray(range) && range.length > 0) {\n\t                var m = new Matrix(self), row = 0;\n\t                range.forEach(function(line){\n\t                    var col = 0;\n\t                    var h = 1;\n\t                    line.forEach(function(el){\n\t                        var isRange = el instanceof RangeRef;\n\t                        if (el instanceof Ref && !isRange) {\n\t                            el = self.getRefData(el);\n\t                        }\n\t                        if (isRange || Array.isArray(el)) {\n\t                            el = self.asMatrix(el);\n\t                        }\n\t                        if (el instanceof Matrix) {\n\t                            el.each(function(el, r, c){\n\t                                m.set(row + r, col + c, el);\n\t                            });\n\t                            h = Math.max(h, el.height);\n\t                            col += el.width;\n\t                        } else {\n\t                            if(typeof el === \"string\" && el.length && !isNaN(el)) {\n\t                                el = Number(el);\n\t                            }\n\n\t                            m.set(row, col++, el);\n\t                        }\n\t                    });\n\t                    row += h;\n\t                });\n\t                return m;\n\t            }\n\t        },\n\n\t        getRefCells: function(refs, hiddenInfo, wantNulls) {\n\t            var f = this.formula;\n\t            return this.ss.getRefCells(refs, hiddenInfo, f.sheet, f.row, f.col, wantNulls);\n\t        },\n\n\t        getRefData: function(ref, wantNulls) {\n\t            var f = this.formula;\n\t            return this.ss.getData(ref, f.sheet, f.row, f.col, wantNulls);\n\t        },\n\n\t        workbook: function() {\n\t            return this.ss.workbook;\n\t        }\n\t    });\n\n\t    var Matrix = Class.extend({\n\t        init: function Matrix(context) {\n\t            this.context = context;\n\t            this.height = 0;\n\t            this.width = 0;\n\t            this.data = [];\n\t        },\n\t        clone: function() {\n\t            var m = new Matrix(this.context);\n\t            m.height = this.height;\n\t            m.width = this.width;\n\t            m.data = this.data.map(function(row){ return row.slice(); });\n\t            return m;\n\t        },\n\t        get: function(row, col) {\n\t            var line = this.data[row];\n\t            var val = line ? line[col] : null;\n\t            return val instanceof Ref ? this.context.getRefData(val) : val;\n\t        },\n\t        getNA: function(row, col) {\n\t            if (row < this.height && col < this.width) {\n\t                return this.get(row, col);\n\t            }\n\t            return new CalcError(\"N/A\");\n\t        },\n\t        set: function(row, col, data) {\n\t            var line = this.data[row];\n\t            if (line == null) {\n\t                line = this.data[row] = [];\n\t            }\n\t            line[col] = data;\n\t            if (row >= this.height) {\n\t                this.height = row + 1;\n\t            }\n\t            if (col >= this.width) {\n\t                this.width = col + 1;\n\t            }\n\t        },\n\t        each: function(f, includeEmpty) {\n\t            for (var row = 0; row < this.height; ++row) {\n\t                for (var col = 0; col < this.width; ++col) {\n\t                    var val = this.get(row, col);\n\t                    if (includeEmpty || val != null) {\n\t                        val = f.call(this.context, val, row, col);\n\t                        if (val !== undefined) {\n\t                            return val;\n\t                        }\n\t                    }\n\t                }\n\t            }\n\t        },\n\t        map: function(f, includeEmpty) {\n\t            var m = new Matrix(this.context);\n\t            this.each(function(el, row, col){\n\t                // here `this` is actually the context\n\t                m.set(row, col, f.call(this, el, row, col));\n\t            }, includeEmpty);\n\t            return m;\n\t        },\n\t        eachRow: function(f) {\n\t            for (var row = 0; row < this.height; ++row) {\n\t                var val = f.call(this.context, row);\n\t                if (val !== undefined) {\n\t                    return val;\n\t                }\n\t            }\n\t        },\n\t        eachCol: function(f) {\n\t            for (var col = 0; col < this.width; ++col) {\n\t                var val = f.call(this.context, col);\n\t                if (val !== undefined) {\n\t                    return val;\n\t                }\n\t            }\n\t        },\n\t        mapRow: function(f) {\n\t            var m = new Matrix(this.context);\n\t            this.eachRow(function(row){\n\t                m.set(row, 0, f.call(this.context, row));\n\t            });\n\t            return m;\n\t        },\n\t        mapCol: function(f) {\n\t            var m = new Matrix(this.context);\n\t            this.eachCol(function(col){\n\t                m.set(0, col, f.call(this.context, col));\n\t            });\n\t            return m;\n\t        },\n\t        toString: function() {\n\t            return JSON.stringify(this.data);\n\t        },\n\t        transpose: function() {\n\t            var m = new Matrix(this.context);\n\t            this.each(function(el, row, col){\n\t                m.set(col, row, el);\n\t            });\n\t            return m;\n\t        },\n\t        unit: function(n) {\n\t            this.width = this.height = n;\n\t            var a = this.data = new Array(n);\n\t            for (var i = n; --i >= 0;) {\n\t                var row = a[i] = new Array(n);\n\t                for (var j = n; --j >= 0;) {\n\t                    row[j] = i == j ? 1 : 0;\n\t                }\n\t            }\n\t            return this;\n\t        },\n\t        multiply: function(b) {\n\t            var a = this, m = new Matrix(a.context);\n\t            for (var row = 0; row < a.height; ++row) {\n\t                for (var col = 0; col < b.width; ++col) {\n\t                    var s = 0;\n\t                    for (var i = 0; i < a.width; ++i) {\n\t                        var va = a.get(row, i);\n\t                        var vb = b.get(i, col);\n\t                        if (typeof va != \"number\" || typeof vb != \"number\") {\n\t                            throw new CalcError(\"VALUE\");\n\t                        }\n\t                        s += va * vb;\n\t                    }\n\t                    m.set(row, col, s);\n\t                }\n\t            }\n\t            return m;\n\t        },\n\t        adds: function(b, s) {\n\t            var a = this, m = new Matrix(a.context);\n\t            var sign = s ? -1 : 1;\n\t            for (var row = 0; row < a.height; ++row) {\n\t                for (var col = 0; col < a.width; ++col) {\n\t                    var x = a.get(row, col),\n\t                        y = b.get(row, col);\n\t                    m.set(row, col, x + sign * y);\n\t                }\n\t            }\n\t            return m;\n\t        },\n\t        determinant: function() {\n\t            var a = this.clone().data;\n\t            var n = a.length;\n\t            var d = 1, C, L, i, k;\n\t            for (C = 0; C < n; C++) {\n\t                for (L = C; (L < n) && (!a[L][C]); L++) {}\n\t                if (L == n) {\n\t                    return 0;\n\t                }\n\t                if (L != C) {\n\t                    d = -d;\n\t                    for (k = C; k < n; k++) {\n\t                        var t = a[C][k];\n\t                        a[C][k] = a[L][k];\n\t                        a[L][k] = t;\n\t                    }\n\t                }\n\t                for (i = C+1; i < n; i++) {\n\t                    for (k = C+1; k < n; k++) {\n\t                        a[i][k] -= a[C][k] * a[i][C] / a[C][C];\n\t                    }\n\t                }\n\t                d *= a[C][C];\n\t            }\n\t            return d;\n\t        },\n\t        inverse: function() {\n\t            var n = this.width;\n\t            var m = this.augment(new Matrix(this.context).unit(n));\n\t            var a = m.data;\n\t            var tmp;\n\n\t            // Gaussian elimination\n\t            // https://en.wikipedia.org/wiki/Gaussian_elimination#Finding_the_inverse_of_a_matrix\n\n\t            // 1. Get zeros below main diagonal\n\t            for (var k = 0; k < n; ++k) {\n\t                var imax = argmax(k, n, function(i){ return a[i][k]; });\n\t                if (!a[imax][k]) {\n\t                    return null; // singular matrix\n\t                }\n\t                if (k != imax) {\n\t                    tmp = a[k];\n\t                    a[k] = a[imax];\n\t                    a[imax] = tmp;\n\t                }\n\t                for (var i = k+1; i < n; ++i) {\n\t                    for (var j = k+1; j < 2*n; ++j) {\n\t                        a[i][j] -= a[k][j] * a[i][k] / a[k][k];\n\t                    }\n\t                    a[i][k] = 0;\n\t                }\n\t            }\n\n\t            // 2. Get 1-s on main diagonal, dividing by pivot\n\t            for (var i = 0; i < n; ++i) {\n\t                for (var f = a[i][i], j = 0; j < 2*n; ++j) {\n\t                    a[i][j] /= f;\n\t                }\n\t            }\n\n\t            // 3. Get zeros above main diagonal.  Actually, we only care to compute the right side\n\t            // here (that will be the inverse), so in the inner loop below we go while j >= n,\n\t            // instead of j >= k.\n\t            for (var k = n; --k >= 0;) {\n\t                for (var i = k; --i >= 0;) {\n\t                    if (a[i][k]) {\n\t                        for (var j = 2*n; --j >= n;) {\n\t                            a[i][j] -= a[k][j] * a[i][k];\n\t                        }\n\t                    }\n\t                }\n\t            }\n\n\t            return m.slice(0, n, n, n);\n\t        },\n\t        augment: function(m) {\n\t            var ret = this.clone(), n = ret.width;\n\t            m.each(function(val, row, col){\n\t                ret.set(row, col + n, val);\n\t            });\n\t            return ret;\n\t        },\n\t        slice: function(row, col, height, width) {\n\t            var m = new Matrix(this.context);\n\t            for (var i = 0; i < height; ++i) {\n\t                for (var j = 0; j < width; ++j) {\n\t                    m.set(i, j, this.get(row + i, col + j));\n\t                }\n\t            }\n\t            return m;\n\t        }\n\n\t        // XXX: debug\n\t        // dump: function() {\n\t        //     this.data.forEach(function(row){\n\t        //         console.log(row.map(function(val){\n\t        //             var str = val.toFixed(3).replace(/\\.?0*$/, function(s){\n\t        //                 return [ \"\", \" \", \"  \", \"   \", \"    \" ][s.length];\n\t        //             });\n\t        //             if (val >= 0) { str = \" \" + str; }\n\t        //             return str;\n\t        //         }).join(\"  \"));\n\t        //     });\n\t        // }\n\t    });\n\n\t    function argmax(i, end, f) {\n\t        var max = f(i), pos = i;\n\t        while (++i < end) {\n\t            var v = f(i);\n\t            if (v > max) {\n\t                max = v;\n\t                pos = i;\n\t            }\n\t        }\n\t        return pos;\n\t    }\n\n\t    /* -----[ Formula ]----- */\n\n\t    var Formula = Class.extend({\n\t        init: function Formula(refs, handler, printer, sheet, row, col, arrayFormulaRange){\n\t            this.refs = refs;\n\t            this.handler = handler;\n\t            this.print = printer;\n\t            this.absrefs = null;\n\t            this.sheet = sheet;\n\t            this.row = row;\n\t            this.col = col;\n\t            this.onReady = [];\n\t            this.pending = false;\n\t            this.arrayFormulaRange = arrayFormulaRange;\n\t        },\n\t        setArrayFormulaRange: function(ref) {\n\t            this.arrayFormulaRange = ref.clone().setSheet(this.sheet);\n\t        },\n\t        clone: function(sheet, row, col, forceRefs) {\n\t            var lcsheet = sheet.toLowerCase();\n\t            var refs = this.refs;\n\t            var range = this.arrayFormulaRange;\n\t            if (forceRefs || lcsheet != this.sheet.toLowerCase()) {\n\t                refs = refs.map(function(ref){\n\t                    if (!ref.hasSheet() && (!ref.sheet || ref.sheet.toLowerCase() != lcsheet)) {\n\t                        ref = ref.clone().setSheet(sheet);\n\t                    }\n\t                    return ref;\n\t                });\n\t                if (range) {\n\t                    range = range.clone().setSheet(sheet);\n\t                }\n\t            }\n\t            return new Formula(refs, this.handler, this.print, sheet, row, col, range);\n\t        },\n\t        deepClone: function() {\n\t            var refs = this.refs.map(function(ref){ return ref.clone(); });\n\t            return new Formula(refs, this.handler, this.print, this.sheet, this.row, this.col, this.arrayFormulaRange);\n\t        },\n\t        resolve: function(val) {\n\t            this.pending = false;\n\t            this.onReady.forEach(function(callback){\n\t                callback(val);\n\t            });\n\t        },\n\t        exec: function(ss, callback, parentContext) {\n\t            if (\"value\" in this) {\n\t                if (callback) {\n\t                    callback(this.value);\n\t                }\n\t            } else {\n\t                if (callback) {\n\t                    this.onReady.push(callback);\n\t                }\n\n\t                var ctx = new Context(this.resolve, this, ss, parentContext);\n\t                var level = 0;\n\t                // if the call chain leads back to this same formula, we have a circular dependency.\n\t                while (parentContext) {\n\t                    if (parentContext.formula === this) {\n\t                        this.pending = false;\n\t                        ctx.resolve(new CalcError(\"CIRCULAR\"));\n\t                        return;\n\t                    }\n\t                    parentContext = parentContext.parent;\n\t                    ++level;\n\t                }\n\n\t                // pending is still useful for ASYNC formulas\n\t                if (this.pending) {\n\t                    return;\n\t                }\n\t                this.pending = true;\n\n\t                var next = function() {\n\t                    // compute and cache the absolute references\n\t                    if (!this.absrefs) {\n\t                        this.absrefs = this.refs.map(function(ref){\n\t                            return ref.absolute(this.row, this.col);\n\t                        }, this);\n\t                    }\n\n\t                    // finally invoke the handler given to us by the compiler in calc.js\n\t                    this.handler.call(ctx);\n\t                }.bind(this);\n\n\t                if (level < 20) {\n\t                    next();\n\t                } else {\n\t                    setTimeout(next, 0);\n\t                }\n\t            }\n\t        },\n\t        reset: function() {\n\t            this.onReady = [];\n\t            this.pending = false;\n\t            delete this.value;\n\t        },\n\t        renameSheet: function(oldSheetName, newSheetName) {\n\t            oldSheetName = oldSheetName.toLowerCase();\n\t            this.absrefs = null;\n\t            if (this.sheet.toLowerCase() == oldSheetName) {\n\t                this.sheet = newSheetName;\n\t            }\n\t            this.refs.forEach(function(ref){\n\t                ref.renameSheet(oldSheetName, newSheetName);\n\t            });\n\t        },\n\t        adjust: function(affectedSheet, operation, start, delta) {\n\t            affectedSheet = affectedSheet.toLowerCase();\n\t            var formulaRow = this.row;\n\t            var formulaCol = this.col;\n\t            var formulaSheet = this.sheet.toLowerCase();\n\t            var formulaMoves = false;\n\t            if (formulaSheet == affectedSheet) {\n\t                // move formula if it's after the change point\n\t                if (operation == \"row\" && formulaRow >= start) {\n\t                    this.row += delta;\n\t                    formulaMoves = true;\n\t                }\n\t                if (operation == \"col\" && formulaCol >= start) {\n\t                    this.col += delta;\n\t                    formulaMoves = true;\n\t                }\n\t            }\n\t            var newFormulaRow = this.row;\n\t            var newFormulaCol = this.col;\n\t            this.absrefs = null;\n\t            var prevRefs = this.refs;\n\t            var modified = formulaMoves;\n\t            this.refs = prevRefs.map(function(ref){\n\t                var newRef = adjust(ref);\n\t                if (!modified && !sameRef(newRef, ref)) {\n\t                    modified = true;\n\t                }\n\t                return newRef;\n\t            });\n\n\t            var prevRange = this.arrayFormulaRange;\n\t            if (prevRange) {\n\t                this.arrayFormulaRange = adjust(prevRange);\n\t                if (!modified && !sameRef(prevRange, this.arrayFormulaRange)) {\n\t                    modified = true;\n\t                }\n\t            }\n\n\t            if (modified) {\n\t                // return a clone of the original formula.  needed to undo operations like\n\t                // deleteRow, which can transform a reference into NULL.\n\t                return new Formula(prevRefs, this.handler, this.print, this.sheet, formulaRow, formulaCol, prevRange);\n\t            }\n\n\t            function adjust(ref){\n\t                if (ref === NULL) {\n\t                    return ref;\n\t                }\n\t                if (ref.sheet.toLowerCase() != affectedSheet) {\n\t                    if (formulaMoves) {\n\t                        // a reference to another sheet should still point to the same location\n\t                        // after adjustment; thus if row/col was removed before formula, relative\n\t                        // references must be adjusted by delta.\n\t                        if (operation == \"row\" && formulaRow >= start) {\n\t                            ref = ref.relative(delta, 0);\n\t                        }\n\t                        if (operation == \"col\" && formulaCol >= start) {\n\t                            ref = ref.relative(0, delta);\n\t                        }\n\t                    }\n\t                    return ref;\n\t                }\n\t                return ref.adjust(\n\t                    formulaRow, formulaCol,\n\t                    newFormulaRow, newFormulaCol,\n\t                    operation == \"row\",\n\t                    start, delta\n\t                );\n\t            }\n\t        },\n\t        toString: function() {\n\t            return this.print(this.row, this.col);\n\t        }\n\t    });\n\n\t    function sameRef(r1, r2) {\n\t        // note: r1.eq(r2) will not do, because it returns true for A1 and A1:A1 (CellRef\n\t        // vs. RangeRef).  To properly undo we need to assert that the references are exactly the\n\t        // same (including type).\n\t        if (r1.constructor !== r2.constructor) {\n\t            return false;\n\t        }\n\t        if (r1 instanceof CellRef) {\n\t            return r1.sheet == r2.sheet\n\t                && r1.row == r2.row\n\t                && r1.col == r2.col\n\t                && r1.rel == r2.rel;\n\t        }\n\t        if (r1 instanceof RangeRef) {\n\t            return sameRef(r1.topLeft     , r2.topLeft)\n\t                && sameRef(r1.bottomRight , r2.bottomRight)\n\t                && r1.endSheet == r2.endSheet;\n\t        }\n\t        if (r1 instanceof UnionRef) {\n\t            var i = r1.refs.length;\n\t            if (i != r2.refs.length) {\n\t                return false;\n\t            }\n\t            while (--i >= 0) {\n\t                if (!sameRef(r1.refs[i], r2.refs[i])) {\n\t                    return false;\n\t                }\n\t            }\n\t        }\n\t        return true;\n\t    }\n\n\t    // spreadsheet functions --------\n\t    var FUNCS = Object.create(null);\n\n\t    FUNCS[\"if\"] = function(callback, args) {\n\t        var self = this;\n\t        var co = args[0], th = args[1], el = args[2];\n\t        // XXX: I don't like this resolveCells here.  We should try to declare IF with\n\t        // defineFunction.\n\t        this.resolveCells([ co ], function(){\n\t            var comatrix = self.asMatrix(co);\n\t            if (comatrix) {\n\t                // XXX: calling both branches in this case, since we'll typically need values from\n\t                // both.  We could optimize and call them only when first needed, but oh well.\n\t                th(function(th){\n\t                    el(function(el){\n\t                        var thmatrix = self.asMatrix(th);\n\t                        var elmatrix = self.asMatrix(el);\n\t                        callback(comatrix.map(function(val, row, col){\n\t                            if (val instanceof CalcError) {\n\t                                return val;\n\t                            } else if (self.bool(val)) {\n\t                                return thmatrix ? thmatrix.get(row, col) : th;\n\t                            } else {\n\t                                return elmatrix ? elmatrix.get(row, col) : el;\n\t                            }\n\t                        }));\n\t                    });\n\t                });\n\t            } else {\n\t                co = this.force(co);\n\t                if (co instanceof CalcError) {\n\t                    callback(co);\n\t                } else if (self.bool(co)) {\n\t                    th(callback);\n\t                } else {\n\t                    el(callback);\n\t                }\n\t            }\n\t        });\n\t    };\n\n\t    FUNCS[\"φ\"] = function(callback) {\n\t        callback((1+Math.sqrt(5))/2);\n\t    };\n\n\t    // Lasciate ogni speranza, voi ch'entrate.\n\t    //\n\t    // XXX: document this function.\n\t    function compileArgumentChecks(functionName, args) {\n\t        var arrayArgs = \"function arrayArgs(args) { var xargs = [], width = 0, height = 0, arrays = [], i = 0; \";\n\t        var resolve = \"function resolve(args, callback) { var toResolve = [], i = 0; \";\n\t        var name, forced, main = \"'use strict'; function check(args) { var stack = [], tmp, xargs = [], i = 0, m, err = 'VALUE'; \", haveForced = false;\n\t        var canBeArrayArg = false, hasArrayArgs = false;\n\t        main += args.map(comp).join(\"\");\n\t        main += \"if (i < args.length) return new CalcError('N/A'); \";\n\t        main += \"return xargs; } \";\n\t        arrayArgs += \"return { args: xargs, width: width, height: height, arrays: arrays }; } \";\n\n\t        var f;\n\t        if (haveForced) {\n\t            resolve += \"this.resolveCells(toResolve, callback); } \";\n\t            f = new Function(\"CalcError\", \"round\", main + resolve + arrayArgs + \" return { resolve: resolve, check: check, arrayArgs: arrayArgs };\");\n\t        } else {\n\t            f = new Function(\"CalcError\", \"round\", main + \" return { check: check };\");\n\t        }\n\t        f = f(CalcError, limitPrecision);\n\t        if (!hasArrayArgs) {\n\t            delete f.arrayArgs;\n\t        }\n\t        return f;\n\n\t        function comp(x) {\n\t            name = x[0];\n\t            var code = \"{ \";\n\t            if (Array.isArray(name)) {\n\t                arrayArgs += \"while (i < args.length) { \";\n\t                resolve += \"while (i < args.length) { \";\n\t                code += \"xargs.push(tmp = []); stack.push(xargs); xargs = tmp; \";\n\t                code += \"while (i < args.length) { \";\n\t                code += x.map(comp).join(\"\");\n\t                code += \"} \";\n\t                code += \"xargs = stack.pop(); \";\n\t                resolve += \"} \";\n\t                arrayArgs += \"} \";\n\t            } else if (name == \"+\") {\n\t                arrayArgs += \"while (i < args.length) { \";\n\t                resolve += \"while (i < args.length) { \";\n\t                code += \"if (i >= args.length) return new CalcError('N/A'); \";\n\t                code += \"xargs.push(tmp = []); stack.push(xargs); xargs = tmp; \";\n\t                code += \"do { \";\n\t                code += x.slice(1).map(comp).join(\"\");\n\t                code += \"} while (i < args.length); \";\n\t                code += \"xargs = stack.pop(); \";\n\t                resolve += \"} \";\n\t                arrayArgs += \"} \";\n\t            } else if (name == \"?\") {\n\t                // standalone assertion without a new argument\n\t                code += \"if (!(\" + cond(x[1]) + \")) return new CalcError(err); \";\n\t            } else {\n\t                var type = x[1];\n\t                if (Array.isArray(type) && /^#?collect/.test(type[0])) {\n\t                    var wantNulls = /!$/.test(type[0]);\n\t                    var n = type[2];\n\t                    force();\n\t                    code += \"try {\"\n\t                        + \"var $\" + name + \" = this.cellValues(args.slice(i\";\n\t                    if (n) {\n\t                        code += \", i + \" + n;\n\t                    }\n\t                    code += \")\" + (wantNulls ? \",true\" : \"\") + \").reduce(function(ret, $\"+name+\"){ \";\n\t                    if (type[0].charAt(0) != \"#\") {\n\t                        code += \"if ($\"+name+\" instanceof CalcError) throw $\"+name+\"; \";\n\t                    }\n\t                    code += \"if (\" + cond(type[1]) + \") ret.push($\"+name+\"); \";\n\t                    code += \"return ret; \";\n\t                    code += \"}.bind(this), []); \";\n\t                    if (n) {\n\t                        code += \"i += \" + n + \"; \";\n\t                    } else {\n\t                        code += \"i = args.length; \";\n\t                    }\n\t                    code += \"xargs.push($\"+name+\")\"\n\t                        + \"} catch(ex) { if (ex instanceof CalcError) return ex; throw ex; } \";\n\t                    resolve += \"toResolve.push(args.slice(i)); \";\n\t                } else if (type == \"rest\") {\n\t                    code += \"xargs.push(args.slice(i)); i = args.length; \";\n\t                } else {\n\t                    if ((canBeArrayArg = /^\\*/.test(name))) {\n\t                        hasArrayArgs = true;\n\t                        name = name.substr(1);\n\t                    }\n\t                    code += \"var $\" + name + \" = args[i++]; \";\n\t                    var allowError = false;\n\t                    if (/!$/.test(type)) {\n\t                        type = type.substr(0, type.length - 1);\n\t                        allowError = true;\n\t                    } else {\n\t                        code += \"if ($\"+name+\" instanceof CalcError) return $\"+name+\"; \";\n\t                    }\n\t                    code += typeCheck(type, allowError) + \"xargs.push($\"+name+\"); \";\n\t                }\n\t            }\n\t            code += \"} \";\n\t            return code;\n\t        }\n\n\t        function force() {\n\t            if (forced) {\n\t                return \"$\"+name+\"\";\n\t            }\n\t            haveForced = true;\n\t            forced = true;\n\t            resolve += \"toResolve.push(args[i++]); \";\n\t            return \"($\"+name+\" = this.force($\"+name+\"))\";\n\t        }\n\n\t        function forceNum(round) {\n\t            return \"(\"\n\t                +     (round\n\t                       ? (\"(typeof \" + force() + \" == 'number' ? ($\"+name+\" = round($\"+name+\"), true) : false) || \")\n\t                       : (\"(typeof \" + force() + \" == 'number') || \"))\n\t                +     \"(typeof $\"+name+\" == 'boolean' ? ($\"+name+\" = +$\" + name + \", true) : false) || \"\n\t                +     \"(typeof $\"+name+\" == 'string' && !/^(?:=|true|false)/i.test($\"+name+\") ? (\"\n\t                +       \"tmp = kendo.spreadsheet.calc.parse(0, 0, 0, $\"+name+\"), \"\n\t                +       \"/^date|number|percent$/.test(tmp.type) ? ($\"+name+\" = +tmp.value, true) : false\"\n\t                +     \") : false)\"\n\t                +  \")\";\n\t        }\n\n\t        function typeCheck(type, allowError) {\n\t            forced = false;\n\t            var ret = \"if (!(\" + cond(type) + \")) { \";\n\t            if (forced && !allowError) {\n\t                ret += \" if ($\" + name + \" instanceof CalcError) return $\" + name + \"; \";\n\t            }\n\t            ret += \"return new CalcError(err); } \";\n\t            if (!forced) {\n\t                resolve += \"i++; \";\n\t            }\n\t            if (canBeArrayArg) {\n\t                arrayArgs += \"var $\" + name + \" = this._arrayArg(args[i]); \"\n\t                    + \"if ($\" + name + \") { \"\n\t                    + \"xargs.push($\" + name + \"); \"\n\t                    + \"width = Math.max(width, $\" + name + \".width); \"\n\t                    + \"height = Math.max(height, $\" + name + \".height); \"\n\t                    + \"arrays.push(true) } else { \"\n\t                    + \"xargs.push(args[i]); \"\n\t                    + \"arrays.push(false); } i++; \";\n\t            } else {\n\t                arrayArgs += \"xargs.push(args[i++]); arrays.push(false); \";\n\t            }\n\t            return ret;\n\t        }\n\n\t        function cond(type) {\n\t            if (Array.isArray(type)) {\n\t                if (type[0] == \"or\") {\n\t                    return \"(\" + type.slice(1).map(cond).join(\") || (\") + \")\";\n\t                }\n\t                if (type[0] == \"and\") {\n\t                    return \"(\" + type.slice(1).map(cond).join(\") && (\") + \")\";\n\t                }\n\t                if (type[0] == \"values\") {\n\t                    return \"(\" + type.slice(1).map(function(val){\n\t                        return force() + \" === \" + val;\n\t                    }).join(\") || (\") + \")\";\n\t                }\n\t                if (type[0] == \"null\") {\n\t                    return \"(\" + cond(\"null\") + \" ? (($\"+name+\" = \" + type[1] + \"), true) : false)\";\n\t                }\n\t                if (type[0] == \"between\" || type[0] == \"[between]\") {\n\t                    return \"(\" + force() + \" >= \" + type[1] + \" && \" + \"$\"+name+\" <= \" + type[2] + \" ? true : ((err = 'NUM'), false))\";\n\t                }\n\t                if (type[0] == \"(between)\") {\n\t                    return \"(\" + force() + \" > \" + type[1] + \" && \" + \"$\"+name+\" < \" + type[2] + \" ? true : ((err = 'NUM'), false))\";\n\t                }\n\t                if (type[0] == \"(between]\") {\n\t                    return \"(\" + force() + \" > \" + type[1] + \" && \" + \"$\"+name+\" <= \" + type[2] + \" ? true : ((err = 'NUM'), false))\";\n\t                }\n\t                if (type[0] == \"[between)\") {\n\t                    return \"(\" + force() + \" >= \" + type[1] + \" && \" + \"$\"+name+\" < \" + type[2] + \" ? true : ((err = 'NUM'), false))\";\n\t                }\n\t                if (type[0] == \"assert\") {\n\t                    var err = type[2] || \"N/A\";\n\t                    return \"((\" + type[1] + \") ? true : (err = \" + JSON.stringify(err) + \", false))\";\n\t                }\n\t                if (type[0] == \"not\") {\n\t                    return \"!(\" + cond(type[1]) + \")\";\n\t                }\n\t                throw new Error(\"Unknown array type condition: \" + type[0]);\n\t            }\n\t            if (type == \"number\" || type == \"datetime\") {\n\t                return forceNum(true);\n\t            }\n\t            if (type == \"number!\") {\n\t                return \"(typeof \" + force() + \" == 'number' ? ($\"+name+\" = round($\"+name+\"), true) : false)\";\n\t            }\n\t            if (type == \"integer\" || type == \"date\") {\n\t                return \"(\" + forceNum() + \" && (($\"+name+\" |= 0), true))\";\n\t            }\n\t            if (type == \"divisor\") {\n\t                return \"(\" + forceNum(true) + \" && ($\"+name+\" == 0 ? ((err = 'DIV/0'), false) : true))\";\n\t            }\n\t            if (type == \"number+\") {\n\t                return \"(\" + forceNum(true) + \" && ($\"+name+\" >= 0 ? true : ((err = 'NUM'), false)))\";\n\t            }\n\t            if (type == \"integer+\") {\n\t                return \"(\" + forceNum() + \" && (($\"+name+\" |= 0) >= 0 ? true : ((err = 'NUM'), false)))\";\n\t            }\n\t            if (type == \"number++\") {\n\t                return \"(\" + forceNum(true) + \" && ($\"+name+\" > 0 ? true : ((err = 'NUM'), false)))\";\n\t            }\n\t            if (type == \"integer++\") {\n\t                return \"(\" + forceNum() + \" && (($\"+name+\" |= 0) > 0 ? true : ((err = 'NUM'), false)))\";\n\t            }\n\t            if (type == \"string\") {\n\t                return \"((typeof \" + force() + \" == 'string' || typeof $\"+name+\" == 'boolean' || typeof $\"+name+\" == 'number') ? ($\"+name+\" += '', true) : ($\"+name+\" === undefined ? (($\"+name+\" = ''), true) : false))\";\n\t            }\n\t            if (type == \"boolean\") {\n\t                return \"(typeof \" + force() + \" == 'boolean')\";\n\t            }\n\t            if (type == \"logical\") {\n\t                return \"(typeof \" + force() + \" == 'boolean' || (typeof $\"+name+\" == 'number' ? ($\"+name+\" = !!$\"+name+\", true) : false))\";\n\t            }\n\t            if (type == \"matrix\") {\n\t                force();\n\t                return \"((m = this.asMatrix($\"+name+\")) ? ($\"+name+\" = m) : false)\";\n\t            }\n\t            if (type == \"#matrix\") {\n\t                return \"((m = this.asMatrix($\"+name+\")) ? ($\"+name+\" = m) : false)\";\n\t            }\n\t            if (type == \"ref\") {\n\t                return \"($\"+name+\" instanceof kendo.spreadsheet.Ref)\";\n\t            }\n\t            if (type == \"area\") {\n\t                return \"($\"+name+\" instanceof kendo.spreadsheet.CellRef || $\"+name+\" instanceof kendo.spreadsheet.RangeRef)\";\n\t            }\n\t            if (type == \"cell\") {\n\t                return \"($\"+name+\" instanceof kendo.spreadsheet.CellRef)\";\n\t            }\n\t            if (type == \"null\") {\n\t                return \"(\" + force() + \" == null)\";\n\t            }\n\t            if (type == \"anyvalue\") {\n\t                return \"(\" + force() + \" != null && i <= args.length)\";\n\t            }\n\t            if (type == \"forced\") {\n\t                return \"(\" + force() + \", i <= args.length)\";\n\t            }\n\t            if (type == \"anything\") {\n\t                return \"(i <= args.length)\";\n\t            }\n\t            if (type == \"blank\") {\n\t                return \"(\" + force() + \" == null || $\"+name+\" === '')\";\n\t            }\n\t            throw new Error(\"Can't check for type: \" + type);\n\t        }\n\t    }\n\n\t    function limitPrecision(num) {\n\t        return num === parseInt(num, 10) ? num : +num.toPrecision(14);\n\t    }\n\n\t    function maybeRoundFloatErrors(num) {\n\t        if (typeof num == \"number\") {\n\t            return limitPrecision(num);\n\t        } else {\n\t            return num;\n\t        }\n\t    }\n\n\t    function withErrorHandling(obj, f, args) {\n\t        if (args instanceof CalcError) {\n\t            return args;\n\t        }\n\t        try {\n\t            return f.apply(obj, args);\n\t        } catch(ex) {\n\t            if (ex instanceof CalcError) {\n\t                return ex;\n\t            } else {\n\t                throw ex;\n\t            }\n\t        }\n\t    }\n\n\t    function makeSyncFunction(handler, resolve, check, arrayArgs) {\n\t        return function(callback, args) {\n\t            function doit() {\n\t                if (arrayArgs) {\n\t                    var x = arrayArgs.call(this, args);\n\t                    args = x.args;\n\t                    if (x.width > 0 && x.height > 0) {\n\t                        var result = new Matrix(this);\n\t                        for (var row = 0; row < x.height; ++row) {\n\t                            for (var col = 0; col < x.width; ++col) {\n\t                                var xargs = [];\n\t                                for (var i = 0; i < args.length; ++i) {\n\t                                    if (x.arrays[i]) {\n\t                                        xargs[i] = args[i].getNA(row, col);\n\t                                    } else {\n\t                                        xargs[i] = args[i];\n\t                                    }\n\t                                }\n\t                                xargs = check.call(this, xargs);\n\t                                result.set(row, col, withErrorHandling(this, handler, xargs));\n\t                            }\n\t                        }\n\t                        return callback(result);\n\t                    }\n\t                }\n\t                var xargs = check.call(this, args);\n\t                callback(withErrorHandling(this, handler, xargs));\n\t            }\n\t            if (resolve) {\n\t                resolve.call(this, args, doit);\n\t            } else {\n\t                doit.call(this);\n\t            }\n\t        };\n\t    }\n\n\t    function makeAsyncFunction(handler, resolve, check, arrayArgs) {\n\t        return function(callback, args) {\n\t            function doit() {\n\t                if (arrayArgs) {\n\t                    var x = arrayArgs.call(this, args);\n\t                    args = x.args;\n\t                    if (x.width > 0 && x.height > 0) {\n\t                        var result = new Matrix(this);\n\t                        var count = x.width * x.height;\n\t                        var makeCallback = function(row, col) {\n\t                            return function(value) {\n\t                                result.set(row, col, value);\n\t                                --count;\n\t                                if (count === 0) {\n\t                                    return callback(result);\n\t                                }\n\t                            };\n\t                        };\n\t                        for (var row = 0; row < x.height && count > 0; ++row) {\n\t                            for (var col = 0; col < x.width && count > 0; ++col) {\n\t                                var xargs = [];\n\t                                for (var i = 0; i < args.length; ++i) {\n\t                                    if (x.arrays[i]) {\n\t                                        xargs[i] = args[i].getNA(row, col);\n\t                                    } else {\n\t                                        xargs[i] = args[i];\n\t                                    }\n\t                                }\n\t                                xargs = check.call(this, xargs);\n\t                                if (xargs instanceof CalcError) {\n\t                                    result.set(row, col, xargs);\n\t                                    --count;\n\t                                    if (count === 0) {\n\t                                        return callback(result);\n\t                                    }\n\t                                } else {\n\t                                    xargs.unshift(makeCallback(row, col));\n\t                                    handler.apply(this, xargs);\n\t                                }\n\t                            }\n\t                        }\n\t                        return;\n\t                    }\n\t                }\n\t                var x = check.call(this, args);\n\t                if (x instanceof CalcError) {\n\t                    callback(x);\n\t                } else {\n\t                    x.unshift(callback);\n\t                    handler.apply(this, x);\n\t                }\n\t            }\n\t            if (resolve) {\n\t                resolve.call(this, args, doit);\n\t            } else {\n\t                doit.call(this);\n\t            }\n\t        };\n\t    }\n\n\t    function defineFunction(name, func) {\n\t        name = name.toLowerCase();\n\t        FUNCS[name] = func;\n\t        return {\n\t            args: function(args, log) {\n\t                var code = compileArgumentChecks(name, args);\n\t                // XXX: DEBUG\n\t                if (log) {\n\t                    if (code.arrayArgs) {console.log(code.arrayArgs.toString());}\n\t                    if (code.resolve) {console.log(code.resolve.toString());}\n\t                    if (code.check) {console.log(code.check.toString());}\n\t                }\n\t                var f = FUNCS[name] = makeSyncFunction(func, code.resolve, code.check, code.arrayArgs);\n\t                f.kendoSpreadsheetArgs = args;\n\t                return this;\n\t            },\n\t            argsAsync: function(args, log) {\n\t                var code = compileArgumentChecks(name, args);\n\t                // XXX: DEBUG\n\t                if (log) {\n\t                    if (code.arrayArgs) {console.log(code.arrayArgs.toString());}\n\t                    if (code.resolve) {console.log(code.resolve.toString());}\n\t                    if (code.check) {console.log(code.check.toString());}\n\t                }\n\t                var f = FUNCS[name] = makeAsyncFunction(func, code.resolve, code.check, code.arrayArgs);\n\t                f.kendoSpreadsheetArgs = args;\n\t                return this;\n\t            }\n\t        };\n\t    }\n\n\t    /* -----[ date calculations ]----- */\n\n\t    // Julian days algorithms from http://www.hermetic.ch/cal_stud/jdn.htm#comp\n\n\t    function dateToJulianDays(y, m, d) {\n\t        m++;\n\t        return ((1461 * (y + 4800 + ((m - 14) / 12 | 0))) / 4 | 0) +\n\t            ((367 * (m - 2 - 12 * ((m - 14) / 12 | 0))) / 12 | 0) -\n\t            ((3 * (((y + 4900 + ((m - 14) / 12 | 0)) / 100 | 0))) / 4 | 0) +\n\t            d - 32075;\n\t    }\n\n\t    function julianDaysToDate(jd) {\n\t        var l, n, j, i, m, d, y;\n\t        l = jd + 68569;\n\t        n = (4 * l) / 146097 | 0;\n\t        l = l - ((146097 * n + 3) / 4 | 0);\n\t        i = (4000 * (l + 1) / 1461001) | 0;\n\t        l = l - ((1461 * i) / 4 | 0) + 31;\n\t        j = (80 * l) / 2447 | 0;\n\t        d = l - ((2447 * j) / 80 | 0);\n\t        l = j / 11 | 0;\n\t        m = j + 2 - (12 * l);\n\t        y = 100 * (n - 49) + i + l;\n\t        m--;\n\t        return {\n\t            year  : y,\n\t            month : m,\n\t            date  : d,\n\t            day   : (jd + 1) % 7,\n\t            ord   : ORDINAL_ADD_DAYS[isLeapYear(y)][m] + d\n\t        };\n\t    }\n\n\t    // This uses the Google Spreadsheet approach: treat 1899-12-31 as day 1, allowing to avoid\n\t    // implementing the \"Leap Year Bug\" yet still be Excel compatible for dates starting 1900-03-01.\n\t    var BASE_DATE = dateToJulianDays(1900, 0, -1);\n\n\t    var DAYS_IN_MONTH = [ 31, 28, 31,\n\t                          30, 31, 30,\n\t                          31, 31, 30,\n\t                          31, 30, 31 ];\n\n\t    var ORDINAL_ADD_DAYS = [\n\t        [ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 ], // non-leap year\n\t        [ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 ]  // leap year\n\t    ];\n\n\t    function isLeapYear(yr) {\n\t        if (yr % 4) {\n\t            return 0;\n\t        }\n\t        if (yr % 100) {\n\t            return 1;\n\t        }\n\t        if (yr % 400) {\n\t            return 0;\n\t        }\n\t        return 1;\n\t    }\n\n\t    function daysInYear(yr) {\n\t        return isLeapYear(yr) ? 366 : 365;\n\t    }\n\n\t    function daysInMonth(yr, mo) {\n\t        return (isLeapYear(yr) && mo == 1) ? 29 : DAYS_IN_MONTH[mo];\n\t    }\n\n\t    function validDate(yr, mo, da) {\n\t        return mo >= 1 && mo <= 12 && da >= 1 && da <= daysInMonth(yr, mo - 1);\n\t    }\n\n\t    function unpackDate(serial) {\n\t        return julianDaysToDate((serial | 0) + BASE_DATE);\n\t    }\n\n\t    function packDate(year, month, date) {\n\t        return dateToJulianDays(year, month, date) - BASE_DATE;\n\t    }\n\n\t    var MS_IN_MIN = 60 * 1000;\n\t    var MS_IN_HOUR = 60 * MS_IN_MIN;\n\t    var MS_IN_DAY = 24 * MS_IN_HOUR;\n\n\t    function unpackTime(serial) {\n\t        var frac = serial - (serial|0);\n\t        if (frac < 0) {\n\t            frac++;\n\t        }\n\t        var ms = Math.round(MS_IN_DAY * frac);\n\t        var hours = Math.floor(ms / MS_IN_HOUR);\n\t        ms -= hours * MS_IN_HOUR;\n\t        var minutes = Math.floor(ms / MS_IN_MIN);\n\t        ms -= minutes * MS_IN_MIN;\n\t        var seconds = Math.floor(ms / 1000);\n\t        ms -= seconds * 1000;\n\t        return {\n\t            hours: hours,\n\t            minutes: minutes,\n\t            seconds: seconds,\n\t            milliseconds: ms\n\t        };\n\t    }\n\n\t    function serialToDate(serial) {\n\t        var d = unpackDate(serial), t = unpackTime(serial);\n\t        return new Date(d.year, d.month, d.date,\n\t                        t.hours, t.minutes, t.seconds, t.milliseconds);\n\t    }\n\n\t    function packTime(hh, mm, ss, ms) {\n\t        return (hh+(mm+(ss+ms/1000)/60)/60)/24;\n\t    }\n\n\t    function dateToSerial(date) {\n\t        var time = packTime(date.getHours(),\n\t                            date.getMinutes(),\n\t                            date.getSeconds(),\n\t                            date.getMilliseconds());\n\t        date = packDate(date.getFullYear(),\n\t                        date.getMonth(),\n\t                        date.getDate());\n\t        if (date < 0) {\n\t            return date - 1 + time;\n\t        } else {\n\t            return date + time;\n\t        }\n\t    }\n\n\t    function parseDate(str, format) {\n\t        if (format) {\n\t            format = kendo.spreadsheet.formatting.makeDateFormat(format);\n\t        }\n\t        return kendo.parseExactDate(str, format)\n\t            || kendo.parseExactDate(str)\n\t            || kendo.parseExactDate(str, [\n\t                \"MMMM dd yyyy\",\n\t                \"MMMM dd yy\",\n\t                \"MMM dd yyyy\",\n\t                \"MMM dd yy\",\n\t                \"dd MMMM yyyy\",\n\t                \"dd MMMM yy\",\n\t                \"dd MMM yyyy\",\n\t                \"dd MMM yy\",\n\t                \"MMMM dd, yyyy\",\n\t                \"MMMM dd, yy\",\n\t                \"MMM dd, yyyy\",\n\t                \"MMM dd, yy\",\n\t                \"MMMM dd\",\n\t                \"MMM dd\",\n\t                \"MMMM yyyy\",\n\t                \"MMM yyyy\",\n\t                \"dd MMMM\",\n\t                \"dd MMM\"\n\t            ]);\n\t    }\n\n\t    /* -----[ exports ]----- */\n\n\t    exports.CalcError = CalcError;\n\t    exports.Formula = Formula;\n\t    exports.Matrix = Matrix;\n\n\t    exports.packDate = packDate;\n\t    exports.unpackDate = unpackDate;\n\t    exports.packTime = packTime;\n\t    exports.unpackTime = unpackTime;\n\t    exports.serialToDate = serialToDate;\n\t    exports.dateToSerial = dateToSerial;\n\t    exports.daysInMonth = daysInMonth;\n\t    exports.validDate = validDate;\n\t    exports.isLeapYear = isLeapYear;\n\t    exports.daysInYear = daysInYear;\n\t    exports.parseDate = parseDate;\n\t    exports.limitPrecision = limitPrecision;\n\n\t    spreadsheet.dateToNumber = dateToSerial;\n\t    spreadsheet.numberToDate = serialToDate;\n\t    spreadsheet.defineFunction = defineFunction;\n\t    spreadsheet.CalcError = CalcError;\n\n\t    exports.defineFunction = defineFunction;\n\t    exports.defineAlias = function(alias, name) {\n\t        var orig = FUNCS[name];\n\t        if (!orig) {\n\t            throw new Error(\"Function \" + name + \" is not yet defined\");\n\t        }\n\t        if (!orig.kendoSpreadsheetAliases) {\n\t            orig.kendoSpreadsheetAliases = [ name ];\n\t        }\n\t        orig.kendoSpreadsheetAliases.push(alias);\n\t        FUNCS[alias] = orig;\n\t    };\n\t    exports.FUNCS = FUNCS;\n\n\t    /* -----[ Excel operators ]----- */\n\n\t    var NUMBER_OR_ZERO = [ \"or\", \"number\", [ \"null\", 0 ] ];\n\n\t    var ARGS_NUMERIC = [\n\t        [ \"*a\", NUMBER_OR_ZERO ],\n\t        [ \"*b\", NUMBER_OR_ZERO ]\n\t    ];\n\n\t    var ARGS_ANYVALUE = [\n\t        [ \"*a\", \"forced\" ],\n\t        [ \"*b\", \"forced\" ]\n\t    ];\n\n\t    defineFunction(\"binary+\", function(a, b){\n\t        return a + b;\n\t    }).args(ARGS_NUMERIC);\n\n\t    defineFunction(\"binary-\", function(a, b){\n\t        return a - b;\n\t    }).args(ARGS_NUMERIC);\n\n\t    defineFunction(\"binary*\", function(a, b){\n\t        return a * b;\n\t    }).args(ARGS_NUMERIC);\n\n\t    defineFunction(\"binary/\", function(a, b){\n\t        return a / b;\n\t    }).args([\n\t        [ \"*a\", NUMBER_OR_ZERO ],\n\t        [ \"*b\", \"divisor\" ]\n\t    ]);\n\n\t    defineFunction(\"binary^\", function(a, b){\n\t        return Math.pow(a, b);\n\t    }).args(ARGS_NUMERIC);\n\n\t    defineFunction(\"binary&\", function(a, b){\n\t        if (a == null) { a = \"\"; }\n\t        if (b == null) { b = \"\"; }\n\t        return \"\" + a + b;\n\t    }).args([\n\t        [ \"*a\", [ \"or\", \"number\", \"string\", \"boolean\", \"null\" ] ],\n\t        [ \"*b\", [ \"or\", \"number\", \"string\", \"boolean\", \"null\" ] ]\n\t    ]);\n\n\t    function equals(a, b){\n\t        a = typeof(a) === \"string\" ? a.toLowerCase() : a;\n\t        b = typeof(b) === \"string\" ? b.toLowerCase() : b;\n\n\t        // special cases\n\t        if (a === false && b == null) { return true; }\n\t        if (b === false && a == null) { return true; }\n\t        if (a === 0     && b == null) { return true; }\n\t        if (b === 0     && a == null) { return true; }\n\t        if (a === \"\"    && b == null) { return true; }\n\t        if (b === \"\"    && a == null) { return true; }\n\n\t        return a === b;\n\t    }\n\n\t    defineFunction(\"binary=\", equals).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"binary<>\", function(a, b){\n\t        return !equals(a, b);\n\t    }).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"binary<\", binaryCompare(function(a, b){\n\t        return a < b;\n\t    })).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"binary<=\", binaryCompare(function(a, b){\n\t        return a <= b;\n\t    })).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"binary>\", binaryCompare(function(a, b){\n\t        return a > b;\n\t    })).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"binary>=\", binaryCompare(function(a, b){\n\t        return a >= b;\n\t    })).args(ARGS_ANYVALUE);\n\n\t    defineFunction(\"unary+\", function(a){\n\t        return a;\n\t    }).args([\n\t        [ \"*a\", NUMBER_OR_ZERO ]\n\t    ]);\n\n\t    defineFunction(\"unary-\", function(a){\n\t        return -a;\n\t    }).args([\n\t        [ \"*a\", NUMBER_OR_ZERO ]\n\t    ]);\n\n\t    defineFunction(\"unary%\", function(a){\n\t        return a / 100;\n\t    }).args([\n\t        [ \"*a\", NUMBER_OR_ZERO ]\n\t    ]);\n\n\t    // range operator\n\t    defineFunction(\"binary:\", function(a, b){\n\t        return new RangeRef(a, b)\n\t            .setSheet(a.sheet || this.formula.sheet, a.hasSheet());\n\t    }).args([\n\t        [ \"a\", \"cell\" ],\n\t        [ \"b\", \"cell\" ]\n\t    ]);\n\n\t    // union operator\n\t    defineFunction(\"binary,\", function(a, b){\n\t        return new UnionRef([ a, b ]);\n\t    }).args([\n\t        [ \"a\", \"ref\" ],\n\t        [ \"b\", \"ref\" ]\n\t    ]);\n\n\t    // intersection operator\n\t    defineFunction(\"binary \", function(a, b){\n\t        return a.intersect(b);\n\t    }).args([\n\t        [ \"a\", \"ref\" ],\n\t        [ \"b\", \"ref\" ]\n\t    ]);\n\n\t    /* -----[ conditionals ]----- */\n\n\t    defineFunction(\"not\", function(a){\n\t        return !this.bool(a);\n\t    }).args([\n\t        [ \"*a\", [ \"or\", \"anyvalue\", [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    /* -----[ the IS* functions ]----- */\n\n\t    defineFunction(\"isblank\", function(val){\n\t        if (val instanceof CellRef) {\n\t            val = this.getRefData(val);\n\t            return val == null;\n\t        }\n\t        return false;\n\t    }).args([\n\t        [ \"*value\", \"anything!\" ]\n\t    ]);\n\n\t    defineFunction(\"iserror\", function(val){\n\t        return val instanceof CalcError;\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"iserr\", function(val){\n\t        return val instanceof CalcError && val.code != \"N/A\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"isna\", function(val){\n\t        return val instanceof CalcError && val.code == \"N/A\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"islogical\", function(val){\n\t        return typeof val == \"boolean\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"isnontext\", function(val){\n\t        return typeof val != \"string\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"istext\", function(val){\n\t        return typeof val == \"string\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"isnumber\", function(val){\n\t        return typeof val == \"number\";\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ]\n\t    ]);\n\n\t    defineFunction(\"isref\", function(val){\n\t        // apparently should return true only for cell and range\n\t        return val instanceof CellRef || val instanceof RangeRef;\n\t    }).args([\n\t        [ \"*value\", \"anything!\" ]\n\t    ]);\n\n\t    /* -----[ resolve NameRef-s ]----- */\n\n\t    FUNCS[\",getname\"] = function(callback, args) {\n\t        this.fetchName(args[0], callback);\n\t    };\n\n\t    /// utils\n\n\t    function binaryCompare(func) {\n\t        return function(left, right){\n\t            if (typeof left == \"string\" && typeof right != \"string\") {\n\t                right = right == null ? \"\" : right + \"\";\n\t            }\n\t            if (typeof left != \"string\" && typeof right == \"string\") {\n\t                left = left == null ? \"\" : left + \"\";\n\t            }\n\t            if (typeof left == \"number\" && right == null) {\n\t                right = 0;\n\t            }\n\t            if (typeof right == \"number\" && left == null) {\n\t                left = 0;\n\t            }\n\t            if (typeof left == \"string\" && typeof right == \"string\") {\n\t                // string comparison is case insensitive\n\t                left = left.toLowerCase();\n\t                right = right.toLowerCase();\n\t            }\n\t            if (typeof right == typeof left) {\n\t                return func(left, right);\n\t            } else {\n\t                return new CalcError(\"VALUE\");\n\t            }\n\t        };\n\t    }\n\n\t}, __webpack_require__(3));\n\n\n/***/ })\n\n/******/ });","module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ (function(module, exports, __webpack_require__) {\n\n\t__webpack_require__(1671);\n\tmodule.exports = __webpack_require__(1671);\n\n\n/***/ }),\n\n/***/ 3:\n/***/ (function(module, exports) {\n\n\tmodule.exports = function() { throw new Error(\"define cannot be used indirect\"); };\r\n\n\n/***/ }),\n\n/***/ 1628:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"./runtime\");\n\n/***/ }),\n\n/***/ 1662:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"../util/main\");\n\n/***/ }),\n\n/***/ 1671:\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// -*- fill-column: 100 -*-\n\n\t(function(f, define){\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ __webpack_require__(1628), __webpack_require__(1662) ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t})(function(){\n\t    \"use strict\";\n\n\t    // WARNING: removing the following jshint declaration and turning\n\t    // == into === to make JSHint happy will break functionality.\n\t    /* jshint eqnull:true, newcap:false, laxbreak:true, validthis:true */\n\t    /* jshint latedef:false */\n\n\t    var util = kendo.util;\n\t    var spreadsheet = kendo.spreadsheet;\n\t    var calc = spreadsheet.calc;\n\t    var runtime = calc.runtime;\n\t    var defineFunction = runtime.defineFunction;\n\t    var defineAlias = runtime.defineAlias;\n\t    var CalcError = runtime.CalcError;\n\t    var RangeRef = spreadsheet.RangeRef;\n\t    var CellRef = spreadsheet.CellRef;\n\t    var UnionRef = spreadsheet.UnionRef;\n\t    var Matrix = runtime.Matrix;\n\t    var Ref = spreadsheet.Ref;\n\t    var NameRef = spreadsheet.NameRef;\n\t    var daysInMonth = runtime.daysInMonth;\n\t    var packDate = runtime.packDate;\n\t    var unpackDate = runtime.unpackDate;\n\t    var daysInYear = runtime.daysInYear;\n\n\t    /* -----[ Math functions ]----- */\n\n\t    [ \"abs\", \"cos\", \"sin\", \"acos\", \"asin\", \"tan\", \"atan\", \"exp\", \"sqrt\" ].forEach(function(name){\n\t        defineFunction(name, Math[name]).args([\n\t            [ \"*n\", \"number\" ]\n\t        ]);\n\t    });\n\n\t    defineFunction(\"ln\", Math.log).args([\n\t        [ \"*n\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"log\", function(num, base){\n\t        return Math.log(num) / Math.log(base);\n\t    }).args([\n\t        [ \"*num\", \"number++\" ],\n\t        [ \"*base\", [ \"or\", \"number++\", [ \"null\", 10 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$base != 1\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"log10\", function(num){\n\t        return Math.log(num) / Math.log(10);\n\t    }).args([\n\t        [ \"*num\", \"number++\" ]\n\t    ]);\n\n\t    defineFunction(\"pi\", function(){\n\t        return Math.PI;\n\t    }).args([]);\n\n\t    defineFunction(\"sqrtpi\", function(n){\n\t        return Math.sqrt(n * Math.PI);\n\t    }).args([\n\t        [ \"*num\", \"number+\" ]\n\t    ]);\n\n\t    defineFunction(\"degrees\", function(rad){\n\t        return ((180 * rad) / Math.PI) % 360;\n\t    }).args([\n\t        [ \"*radians\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"radians\", function(deg){\n\t        return Math.PI * deg / 180;\n\t    }).args([\n\t        [ \"*degrees\", \"number\" ]\n\t    ]);\n\n\t    function _cosh(n){\n\t        return (Math.exp(n) + Math.exp(-n)) / 2;\n\t    }\n\n\t    defineFunction(\"cosh\", _cosh).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"acosh\", function(n){\n\t        return Math.log(n + Math.sqrt(n - 1) * Math.sqrt(n + 1));\n\t    }).args([\n\t        [ \"*num\", \"number\" ],\n\t        [ \"?\", [ \"assert\", \"$num >= 1\" ] ]\n\t    ]);\n\n\t    function _sinh(n){\n\t        return (Math.exp(n) - Math.exp(-n)) / 2;\n\t    }\n\n\t    defineFunction(\"sinh\", _sinh).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"asinh\", function(n){\n\t        return Math.log(n + Math.sqrt(n * n + 1));\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"sec\", function(n){\n\t        return 1 / Math.cos(n);\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"sech\", function(n){\n\t        return 1 / _cosh(n);\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"csc\", function(n){\n\t        return 1 / Math.sin(n);\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"csch\", function(n){\n\t        return 1 / _sinh(n);\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"atan2\", function(x, y){\n\t        return Math.atan(y / x);\n\t    }).args([\n\t        [ \"*x\", \"divisor\" ],\n\t        [ \"*y\", \"number\" ]\n\t    ]);\n\n\t    function _tanh(n) {\n\t        return _sinh(n) / _cosh(n);\n\t    }\n\n\t    defineFunction(\"tanh\", _tanh).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"atanh\", function(n){\n\t        return Math.log(Math.sqrt(1 - n*n) / (1 - n));\n\t    }).args([\n\t        [ \"*num\", [ \"and\", \"number\", [ \"(between)\", -1, 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"cot\", function(n){\n\t        return 1 / Math.tan(n);\n\t    }).args([\n\t        [ \"*num\", \"divisor\" ]\n\t    ]);\n\n\t    defineFunction(\"coth\", function(n){\n\t        return 1 / _tanh(n);\n\t    }).args([\n\t        [ \"*num\", \"divisor\" ]\n\t    ]);\n\n\t    defineFunction(\"acot\", function(n){\n\t        return Math.PI / 2 - Math.atan(n);\n\t    }).args([\n\t        [ \"*num\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"acoth\", function(n){\n\t        return Math.log((n + 1) / (n - 1)) / 2;\n\t    }).args([\n\t        [ \"*num\", \"number\" ],\n\t        [ \"?\", [ \"or\",\n\t                 [ \"assert\", \"$num < -1\"],\n\t                 [ \"assert\", \"$num > 1\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"power\", function(a, b){\n\t        return Math.pow(a, b);\n\t    }).args([\n\t        [ \"*a\", \"number\" ],\n\t        [ \"*b\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"mod\", function(a, b){\n\t        return a % b;\n\t    }).args([\n\t        [ \"*a\", \"number\" ],\n\t        [ \"*b\", \"divisor\" ]\n\t    ]);\n\n\t    defineFunction(\"quotient\", function(a, b){\n\t        return Math.floor(a / b);\n\t    }).args([\n\t        [ \"*a\", \"number\" ],\n\t        [ \"*b\", \"divisor\" ]\n\t    ]);\n\n\t    defineFunction(\"ceiling\", function(num, s){\n\t        return s ? s * Math.ceil(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", \"number\" ],\n\t        [ \"?\", [ \"assert\", \"$significance >= 0 || $number < 0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"ceiling.precise\", function(num, s){\n\t        s = Math.abs(s);\n\t        return s ? s * Math.ceil(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", [ \"or\", \"number\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineAlias(\"iso.ceiling\", \"ceiling.precise\");\n\n\t    // XXX: how do we know if this function is correct?\n\t    //\n\t    // https://support.office.com/en-gb/article/CEILING-MATH-function-80f95d2f-b499-4eee-9f16-f795a8e306c8\n\t    //\n\t    // “There are many combinations of Significance and Mode values that affect rounding of negative\n\t    // numbers in different ways.” — right, thanks for the info. :-\\\n\t    defineFunction(\"ceiling.math\", function(num, s, mode){\n\t        if (!s || !num) {\n\t            return 0;\n\t        }\n\t        if (num < 0 && ((!mode && s < 0) || (mode && s > 0))) {\n\t            s = -s;\n\t        }\n\t        return s ? s * Math.ceil(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", [ \"or\", \"number\", [ \"null\", \"$number < 0 ? -1 : 1\" ] ] ],\n\t        [ \"*mode\", [ \"or\", \"logical\", [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"floor\", function(num, s){\n\t        return s ? s * Math.floor(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", \"number\" ],\n\t        [ \"?\", [ \"assert\", \"$significance >= 0 || $number < 0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"floor.precise\", function(num, s){\n\t        s = Math.abs(s);\n\t        return s ? s * Math.floor(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", [ \"or\", \"number\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    // XXX: check this\n\t    defineFunction(\"floor.math\", function(num, s, mode){\n\t        if (!s || !num) {\n\t            return 0;\n\t        }\n\t        if (num < 0 && ((!mode && s < 0) || (mode && s > 0))) {\n\t            s = -s;\n\t        }\n\t        return s ? s * Math.floor(num / s) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*significance\", [ \"or\", \"number\", [ \"null\", \"$number < 0 ? -1 : 1\" ] ] ],\n\t        [ \"*mode\", [ \"or\", \"logical\", [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"int\", Math.floor).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"mround\", function(num, mult){\n\t        return mult ? mult * Math.round(num / mult) : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*multiple\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"round\", function(num, digits){\n\t        var sign = num < 0 ? -1 : 1;\n\t        if (sign < 0) { num = -num; }\n\t        digits = Math.pow(10, digits);\n\t        num *= digits;\n\t        num = Math.round(num);\n\t        return sign * num / digits;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*digits\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"roundup\", function(num, digits){\n\t        digits = Math.pow(10, digits);\n\t        num *= digits;\n\t        num = num < 0 ? Math.floor(num) : Math.ceil(num);\n\t        return num / digits;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*digits\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"rounddown\", function(num, digits){\n\t        digits = Math.pow(10, digits);\n\t        num *= digits;\n\t        num = num < 0 ? Math.ceil(num) : Math.floor(num);\n\t        return num / digits;\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*digits\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"even\", function(num){\n\t        var n = num < 0 ? Math.floor(num) : Math.ceil(num);\n\t        return n % 2 ? n + (n < 0 ? -1 : 1) : n;\n\t    }).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"odd\", function(num){\n\t        var n = num < 0 ? Math.floor(num) : Math.ceil(num);\n\t        return n % 2 ? n : n + (n < 0 ? -1 : 1);\n\t    }).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"sign\", function(num){\n\t        return num < 0 ? -1 : num > 0 ? 1 : 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    function _gcd(a, b) {\n\t        while (b) {\n\t            var r = a % b;\n\t            a = b;\n\t            b = r;\n\t        }\n\t        return a;\n\t    }\n\n\t    function _lcm(a, b) {\n\t        return Math.abs(a * b) / _gcd(a, b);\n\t    }\n\n\t    defineFunction(\"gcd\", function(args){\n\t        var a = args[0];\n\t        for (var i = 1; i < args.length; ++i) {\n\t            a = _gcd(a, args[i]);\n\t        }\n\t        return a;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"lcm\", function(args){\n\t        var a = args[0];\n\t        for (var i = 1; i < args.length; ++i) {\n\t            a = _lcm(a, args[i]);\n\t        }\n\t        return a;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"sum\", function(numbers){\n\t        return numbers.reduce(function(sum, num){\n\t            return sum + num;\n\t        }, 0);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"product\", function(numbers){\n\t        return numbers.reduce(function(prod, num){\n\t            return prod * num;\n\t        }, 1);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"sumproduct\", function(first, rest) {\n\t        var sum = 0;\n\t        first.each(function(p, row, col){\n\t            if (typeof p == \"number\") {\n\t                for (var i = 0; i < rest.length; ++i) {\n\t                    var v = rest[i].get(row, col);\n\t                    if (typeof v != \"number\") {\n\t                        return;\n\t                    }\n\t                    p *= v;\n\t                }\n\t                sum += p;\n\t            }\n\t        });\n\t        return sum;\n\t    }).args([\n\t        [ \"a1\", \"matrix\" ],\n\t        [ \"+\",\n\t          [ \"a2\", [ \"and\", \"matrix\",\n\t                    [ \"assert\", \"$a2.width == $a1.width\" ],\n\t                    [ \"assert\", \"$a2.height == $a1.height\" ] ] ] ]\n\t    ]);\n\n\t    defineFunction(\"sumsq\", function(numbers){\n\t        return numbers.reduce(function(sum, num){\n\t            return sum + num * num;\n\t        }, 0);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"sumx2my2\", function(a, b){\n\t        var sum = 0;\n\t        a.each(function(x, row, col){\n\t            var y = b.get(row, col);\n\t            if (typeof x == \"number\" && typeof y == \"number\") {\n\t                sum += x*x - y*y;\n\t            }\n\t        });\n\t        return sum;\n\t    }).args([\n\t        [ \"a\", \"matrix\" ],\n\t        [ \"b\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$b.width == $a.width\" ],\n\t                 [ \"assert\", \"$b.height == $a.height\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"sumx2py2\", function(a, b){\n\t        var sum = 0;\n\t        a.each(function(x, row, col){\n\t            var y = b.get(row, col);\n\t            if (typeof x == \"number\" && typeof y == \"number\") {\n\t                sum += x*x + y*y;\n\t            }\n\t        });\n\t        return sum;\n\t    }).args([\n\t        [ \"a\", \"matrix\" ],\n\t        [ \"b\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$b.width == $a.width\" ],\n\t                 [ \"assert\", \"$b.height == $a.height\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"sumxmy2\", function(a, b){\n\t        var sum = 0;\n\t        a.each(function(x, row, col){\n\t            var y = b.get(row, col);\n\t            if (typeof x == \"number\" && typeof y == \"number\") {\n\t                sum += (x - y) * (x - y);\n\t            }\n\t        });\n\t        return sum;\n\t    }).args([\n\t        [ \"a\", \"matrix\" ],\n\t        [ \"b\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$b.width == $a.width\" ],\n\t                 [ \"assert\", \"$b.height == $a.height\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"seriessum\", function(x, n, m, a){\n\t        var sum = 0;\n\t        a.each(function(coef){\n\t            if (typeof coef != \"number\") {\n\t                throw new CalcError(\"VALUE\");\n\t            }\n\t            sum += coef * Math.pow(x, n);\n\t            n += m;\n\t        });\n\t        return sum;\n\t    }).args([\n\t        [ \"x\", \"number\" ],\n\t        [ \"y\", \"number\" ],\n\t        [ \"m\", \"number\" ],\n\t        [ \"a\", \"matrix\" ]\n\t    ]);\n\n\t    defineFunction(\"min\", function(numbers){\n\t        return numbers.length ? Math.min.apply(Math, numbers) : 0;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"max\", function(numbers){\n\t        return numbers.length ? Math.max.apply(Math, numbers) : 0;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"counta\", function(values){\n\t        return values.length;\n\t    }).args([\n\t        [ \"values\", [ \"#collect\", \"anyvalue\" ] ]\n\t    ]);\n\n\t    defineFunction(\"count\", function(numbers){\n\t        return numbers.length;\n\t    }).args([\n\t        [ \"numbers\", [ \"#collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"countunique\", function(values){\n\t        var count = 0, seen = [];\n\t        values.forEach(function(val){\n\t            if (seen.indexOf(val) < 0) {\n\t                count++;\n\t                seen.push(val);\n\t            }\n\t        });\n\t        return count;\n\t    }).args([\n\t        [ \"values\", [ \"#collect\", \"anyvalue\" ] ]\n\t    ]);\n\n\t    defineFunction(\"countblank\", function(a){\n\t        var count = 0;\n\t        function add(val) {\n\t            if (val == null || val === \"\") {\n\t                count++;\n\t            }\n\t        }\n\t        function loop(args){\n\t            for (var i = 0; i < args.length; ++i) {\n\t                var x = args[i];\n\t                if (x instanceof Matrix) {\n\t                    x.each(add, true);\n\t                } else {\n\t                    add(x);\n\t                }\n\t            }\n\t        }\n\t        loop(a);\n\t        return count;\n\t    }).args([\n\t        [ \"+\", [ \"args\", [ \"or\", \"matrix\", \"anyvalue\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"iseven\", function(num){\n\t        return num % 2 === 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"isodd\", function(num){\n\t        return num % 2 !== 0;\n\t    }).args([\n\t        [ \"*number\", \"number\" ]\n\t    ]);\n\n\t    defineFunction(\"n\", function(val){\n\t        if (typeof val == \"boolean\") {\n\t            return val ? 1 : 0;\n\t        }\n\t        if (typeof val == \"number\") {\n\t            return val;\n\t        }\n\t        return 0;\n\t    }).args([\n\t        [ \"*value\", \"anyvalue\" ]\n\t    ]);\n\n\t    defineFunction(\"na\", function(){\n\t        return new CalcError(\"N/A\");\n\t    }).args([]);\n\n\t    /* -----[ the \"*IFS\" functions ]----- */\n\n\t    // helper function: take `args` like COUNTIFS (see Excel docs) and\n\t    // calls `f` for each cell matching all criteria.  `f` receives\n\t    // `chunks` (parsed args containing matrix and predicate) and\n\t    // row,col of matching cells.\n\t    function forIFS(args, f) {\n\t        var chunks = [], i = 0, matrix = args[0];\n\t        while (i < args.length) {\n\t            chunks.push({\n\t                matrix: args[i++],\n\t                pred: parseCriteria(args[i++])\n\t            });\n\t        }\n\t        ROW: for (var row = 0; row < matrix.height; ++row) {\n\t            COL: for (var col = 0; col < matrix.width; ++col) {\n\t                for (i = 0; i < chunks.length; ++i) {\n\t                    var val = chunks[i].matrix.get(row, col);\n\t                    if (!chunks[i].pred(val == null || val === \"\" ? 0 : val)) {\n\t                        continue COL;\n\t                    }\n\t                }\n\t                f(row, col);\n\t            }\n\t        }\n\t    }\n\n\t    var ARGS_COUNTIFS = [\n\t        [ \"m1\", \"matrix\" ],\n\t        [ \"c1\", \"anyvalue\" ],\n\t        [ [ \"m2\", \"matrix\" ],\n\t          [ \"c2\", \"anyvalue\" ] ]\n\t    ];\n\n\t    defineFunction(\"countifs\", function(m1, c1, rest){\n\t        var count = 0;\n\t        rest.unshift(m1, c1);\n\t        forIFS(rest, function(){ count++; });\n\t        return count;\n\t    }).args(ARGS_COUNTIFS);\n\n\t    var ARGS_SUMIFS = [\n\t        [ \"range\", \"matrix\" ]\n\t    ].concat(ARGS_COUNTIFS);\n\n\t    defineFunction(\"sumifs\", function(range, m1, c1, args){\n\t        // hack: insert a predicate that filters out non-numeric\n\t        // values; should also accept blank cells.  it's safe to\n\t        // modify args.\n\t        args.unshift(range, numericPredicate, m1, c1);\n\t        var sum = 0;\n\t        forIFS(args, function(row, col){\n\t            var val = range.get(row, col);\n\t            if (val) {\n\t                sum += val;\n\t            }\n\t        });\n\t        return sum;\n\t    }).args(ARGS_SUMIFS);\n\n\t    // similar to sumifs, but compute average of matching cells\n\t    defineFunction(\"averageifs\", function(range, m1, c1, args){\n\t        args.unshift(range, numericPredicate, m1, c1);\n\t        var sum = 0, count = 0;\n\t        forIFS(args, function(row, col){\n\t            var val = range.get(row, col);\n\t            if (val == null || val === \"\") {\n\t                val = 0;\n\t            }\n\t            sum += val;\n\t            count++;\n\t        });\n\t        return count ? sum / count : new CalcError(\"DIV/0\");\n\t    }).args(ARGS_SUMIFS);\n\n\t    defineFunction(\"countif\", function(matrix, criteria){\n\t        criteria = parseCriteria(criteria);\n\t        var count = 0;\n\t        matrix.each(function(val){\n\t            if (criteria(val)) {\n\t                count++;\n\t            }\n\t        });\n\t        return count;\n\t    }).args([\n\t        [ \"range\", \"matrix\" ],\n\t        [ \"*criteria\", \"anyvalue\" ]\n\t    ]);\n\n\t    var ARGS_SUMIF = [\n\t        [ \"range\", \"matrix\" ],\n\t        [ \"*criteria\", \"anyvalue\" ],\n\t        [ \"sumRange\", [ \"or\", \"area\", \"#matrix\", [ \"null\", \"$range\" ] ] ]\n\t    ];\n\n\t    function fetchSumRange(continuation) {\n\t        return function(callback, range, criteria, sumRange) {\n\t            var self = this;\n\t            if (sumRange instanceof Ref) {\n\t                // make sure it covers the same area as `range`, as the “spec” mentions:\n\t                //\n\t                //     The sum_range argument does not have to be the same size and shape as the\n\t                //     range argument. The actual cells that are added are determined by using the\n\t                //     upper leftmost cell in the sum_range argument as the beginning cell, and then\n\t                //     including cells that correspond in size and shape to the range argument.\n\t                //\n\t                // It does make one wonder, since only the top-left cell in `sumRange` matters, why\n\t                // should it be a range at all?  Oh well, Excel.\n\t                var r = sumRange.clone().toRangeRef();\n\t                if (r.width() != range.width || r.height() != range.height) {\n\t                    if (!isFinite(r.topLeft.row)) {\n\t                        r.topLeft.row = 0;\n\t                    }\n\t                    if (!isFinite(r.topLeft.col)) {\n\t                        r.topLeft.col = 0;\n\t                    }\n\t                    r.bottomRight.row = r.topLeft.row + range.height - 1;\n\t                    r.bottomRight.col = r.topLeft.col + range.width - 1;\n\t                    return self.resolveCells([ r ], function(){\n\t                        callback(continuation(range, criteria, self.asMatrix(r)));\n\t                    });\n\t                }\n\t            }\n\t            callback(continuation(range, criteria, self.asMatrix(sumRange)));\n\t        };\n\t    }\n\n\t    defineFunction(\"sumif\", fetchSumRange(function(range, criteria, sumRange){\n\t        var sum = 0;\n\t        criteria = parseCriteria(criteria);\n\t        range.each(function(val, row, col){\n\t            if (criteria(val)) {\n\t                var v = sumRange.get(row, col);\n\t                if (numericPredicate(v)) {\n\t                    sum += v || 0;\n\t                }\n\t            }\n\t        });\n\t        return sum;\n\t    })).argsAsync(ARGS_SUMIF);\n\n\t    defineFunction(\"averageif\", fetchSumRange(function(range, criteria, sumRange){\n\t        var sum = 0, count = 0;\n\t        criteria = parseCriteria(criteria);\n\t        range.each(function(val, row, col){\n\t            if (criteria(val)) {\n\t                var v = sumRange.get(row, col);\n\t                if (numericPredicate(v)) {\n\t                    sum += v || 0;\n\t                    count++;\n\t                }\n\t            }\n\t        });\n\t        return count ? sum / count : new CalcError(\"DIV/0\");\n\t    })).argsAsync(ARGS_SUMIF);\n\n\t    (function(def){\n\t        def(\"large\", function(numbers, nth){\n\t            return numbers.sort(descending)[nth];\n\t        });\n\t        def(\"small\", function(numbers, nth){\n\t            return numbers.sort(ascending)[nth];\n\t        });\n\t    })(function(name, handler){\n\t        defineFunction(name, function(matrix, nth){\n\t            var numbers = [];\n\t            var error = matrix.each(function(val){\n\t                if (val instanceof CalcError) {\n\t                    return val;\n\t                }\n\t                if (typeof val == \"number\") {\n\t                    numbers.push(val);\n\t                }\n\t            });\n\t            if (error) {\n\t                return error;\n\t            }\n\t            if (nth > numbers.length) {\n\t                return new CalcError(\"NUM\");\n\t            }\n\t            return handler(numbers, nth - 1);\n\t        }).args([\n\t            [ \"array\", \"matrix\" ],\n\t            [ \"*nth\", \"number++\" ]\n\t        ]);\n\t    });\n\n\t    function _avg(numbers) {\n\t        return numbers.reduce(function(sum, num){\n\t            return sum + num;\n\t        }, 0) / numbers.length;\n\t    }\n\n\t    function _var_sp(numbers, divisor, avg) {\n\t        if (avg == null) {\n\t            avg = _avg(numbers);\n\t        }\n\t        return numbers.reduce(function(sum, num){\n\t            return sum + Math.pow(num - avg, 2);\n\t        }, 0) / divisor;\n\t    }\n\n\t    function _stdev_sp(numbers, divisor) {\n\t        return Math.sqrt(_var_sp(numbers, divisor));\n\t    }\n\n\t    // https://support.office.com/en-sg/article/STDEV-S-function-7d69cf97-0c1f-4acf-be27-f3e83904cc23\n\t    defineFunction(\"stdev.s\", function(numbers){\n\t        return _stdev_sp(numbers, numbers.length - 1);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 2\", \"NUM\" ] ]\n\t    ]);\n\n\t    // https://support.office.com/en-sg/article/STDEV-P-function-6e917c05-31a0-496f-ade7-4f4e7462f285\n\t    defineFunction(\"stdev.p\", function(numbers){\n\t        return _stdev_sp(numbers, numbers.length);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 2\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"var.s\", function(numbers){\n\t        return _var_sp(numbers, numbers.length - 1);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 2\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"var.p\", function(numbers){\n\t        return _var_sp(numbers, numbers.length);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 2\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"median\", function(numbers){\n\t        var n = numbers.length;\n\t        numbers.sort(ascending);\n\t        if (n % 2) {\n\t            // when length is odd, the median is the number in the middle\n\t            return numbers[n >> 1];\n\t        }\n\t        // that's the average of the two middle numbers, written in in a fancy way\n\t        return (numbers[n >>= 1] + numbers[n - 1]) / 2;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length > 0\", \"N/A\" ] ]\n\t    ]);\n\n\t    defineFunction(\"mode.sngl\", function(numbers){\n\t        numbers.sort(ascending);\n\t        var prev = null, count = 0, max = 1, mode = null;\n\t        for (var i = 0; i < numbers.length; ++i) {\n\t            var n = numbers[i];\n\t            if (n != prev) {\n\t                count = 1;\n\t                prev = n;\n\t            } else {\n\t                count++;\n\t            }\n\t            if (count > max) {\n\t                max = count;\n\t                mode = n;\n\t            }\n\t        }\n\t        return mode == null ? new CalcError(\"N/A\") : mode;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"mode.mult\", function(numbers){\n\t        var seen = Object.create(null), max = 2, res = [];\n\t        numbers.forEach(function(num){\n\t            var s = seen[num] || 0;\n\t            seen[num] = ++s;\n\t            if (s == max) {\n\t                res.push(num);\n\t            } else if (s > max) {\n\t                max = s;\n\t                res = [ num ];\n\t            }\n\t        });\n\t        var m = new Matrix(this);\n\t        res.forEach(function(num, i){\n\t            m.set(i, 0, num);\n\t        });\n\t        return m;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    defineFunction(\"geomean\", function(numbers){\n\t        var n = numbers.length;\n\t        var p = numbers.reduce(function(p, num){\n\t            if (num < 0) {\n\t                throw new CalcError(\"NUM\");\n\t            }\n\t            return p * num;\n\t        }, 1);\n\t        return Math.pow(p, 1/n);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length > 0\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"harmean\", function(numbers){\n\t        var n = numbers.length;\n\t        var s = numbers.reduce(function(s, num){\n\t            if (!num) {\n\t                throw new CalcError(\"DIV/0\");\n\t            }\n\t            return s + 1 / num;\n\t        }, 0);\n\t        return n / s;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length > 0\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"trimmean\", function(numbers, p){\n\t        var n = numbers.length;\n\t        numbers.sort(ascending);\n\t        var discard = Math.floor(n * p);\n\t        if (discard % 2) {\n\t            --discard;\n\t        }\n\t        discard /= 2;\n\t        var sum = 0;\n\t        for (var i = discard; i < n-discard; ++i) {\n\t            sum += numbers[i];\n\t        }\n\t        return sum / (n - discard * 2);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"percent\", [ \"and\", \"number\", [ \"[between)\", 0, 1 ] ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length > 0\", \"NUM\" ] ]\n\t    ]);\n\n\t    defineFunction(\"frequency\", function(data, bins){\n\t        // apparently this always returns a vertical matrix in Excel, so we collect all numbers in\n\t        // bins instead of receiving it as a Matrix and try to mimic its shape.\n\t        data.sort(ascending);\n\t        bins.sort(ascending);\n\t        var prev = -Infinity;\n\t        var i = 0;\n\t        function count(max) {\n\t            var n = 0;\n\t            while (i < data.length && data[i] > prev && data[i] <= max) {\n\t                ++n; ++i;\n\t            }\n\t            return n;\n\t        }\n\t        var m = new Matrix(this);\n\t        bins.forEach(function(val, i){\n\t            var n = count(val);\n\t            prev = val;\n\t            m.set(i, 0, n);\n\t        });\n\t        m.set(m.height, 0, data.length - i);\n\t        return m;\n\t    }).args([\n\t        [ \"data\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"bins\", [ \"collect\", \"number\", 1 ] ]\n\t    ]);\n\n\t    defineFunction(\"rank.eq\", function(val, numbers, asc) {\n\t        numbers.sort(asc ? ascending : descending);\n\t        var pos = numbers.indexOf(val);\n\t        return pos < 0 ? new CalcError(\"N/A\") : pos + 1;\n\t    }).args([\n\t        [ \"value\", \"number\" ],\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"order\", [ \"or\", \"logical\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    defineAlias(\"rank\", \"rank.eq\");\n\n\t    defineFunction(\"rank.avg\", function(val, numbers, asc) {\n\t        numbers.sort(asc ? ascending : descending);\n\t        var pos = numbers.indexOf(val);\n\t        if (pos < 0) {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t        for (var i = pos; numbers[i] == val; ++i){}\n\t        return (pos + i + 1) / 2;\n\t    }).args([\n\t        [ \"value\", \"number\" ],\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"order\", [ \"or\", \"logical\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    // formula available at https://support.office.microsoft.com/en-us/article/KURT-function-cbbc2312-dfa6-4cc4-b5c0-1b3c59cc9377\n\t    defineFunction(\"kurt\", function(numbers){\n\t        var n = numbers.length;\n\t        var avg = _avg(numbers);\n\t        var variance = _var_sp(numbers, n-1, avg);\n\t        var stddev = Math.sqrt(variance);\n\t        var sum = numbers.reduce(function(sum, num){\n\t            return sum + Math.pow((num - avg) / stddev, 4);\n\t        }, 0);\n\t        return n*(n+1)/((n-1)*(n-2)*(n-3)) * sum\n\t            - 3*Math.pow(n-1, 2)/((n-2)*(n-3));\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 4\", \"NUM\" ] ]\n\t    ]);\n\n\t    function _percentrank(numbers, x, exc) {\n\t        var nlt = 0, ngt = 0, left = null, right = null, found = false;\n\t        numbers.forEach(function(num){\n\t            if (num < x) {\n\t                nlt++;\n\t                left = left == null ? num : Math.max(left, num);\n\t            } else if (num > x) {\n\t                ngt++;\n\t                right = right == null ? num : Math.min(right, num);\n\t            } else {\n\t                found = true;\n\t            }\n\t        });\n\t        if (!nlt && !ngt) {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t        if (found) {\n\t            if (exc) {\n\t                return (nlt + 1) / (numbers.length + 1);\n\t            }\n\t            return nlt / (nlt + ngt);\n\t        }\n\t        return ((right - x) * _percentrank(numbers, left, exc) +\n\t                (x - left) * _percentrank(numbers, right, exc)) / (right - left);\n\t    }\n\n\t    var ARGS_PERCENTRANK = [\n\t        [ \"array\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"x\", \"number\" ],\n\t        [ \"significance\", [ \"or\", [ \"null\", 3 ], \"integer++\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array.length > 0\", \"NUM\" ] ]\n\t    ];\n\n\t    defineFunction(\"percentrank.inc\", function(numbers, x, significance) {\n\t        var p = _percentrank(numbers, x, 0);\n\t        p = p.toFixed(significance + 1);\n\t        return parseFloat(p.substr(0, p.length - 1));\n\t    }).args(ARGS_PERCENTRANK);\n\n\t    defineFunction(\"percentrank.exc\", function(numbers, x, significance) {\n\t        var p = _percentrank(numbers, x, 1);\n\t        p = p.toFixed(significance + 1);\n\t        return parseFloat(p.substr(0, p.length - 1));\n\t    }).args(ARGS_PERCENTRANK);\n\n\t    defineAlias(\"percentrank\", \"percentrank.inc\");\n\n\t    function _covariance(x, y, divisor) {\n\t        var sum = 0;\n\t        var ax = _avg(x);\n\t        var ay = _avg(y);\n\t        var n = x.length;\n\t        for (var i = 0; i < n; ++i) {\n\t            sum += (x[i] - ax) * (y[i] - ay);\n\t        }\n\t        return sum / divisor;\n\t    }\n\n\t    defineFunction(\"covariance.p\", function(x, y){\n\t        return _covariance(x, y, x.length);\n\t    }).args([\n\t        [ \"array1\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"array2\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length == $array2.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length > 0\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"covariance.s\", function(x, y){\n\t        return _covariance(x, y, x.length - 1);\n\t    }).args([\n\t        [ \"array1\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"array2\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length == $array2.length\", \"N/A\" ] ],\n\t        [ \"?\", [ \"assert\", \"$array1.length > 1\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineAlias(\"covar\", \"covariance.p\");\n\n\t    /* -----[ Factorials ]----- */\n\n\t    var _fact = util.memoize(function(n){\n\t        for (var i = 2, fact = 1; i <= n; ++i) {\n\t            fact *= i;\n\t        }\n\t        return fact;\n\t    });\n\n\t    defineFunction(\"fact\", _fact).args([\n\t        [ \"*n\", \"integer+\" ]\n\t    ]);\n\n\t    defineFunction(\"factdouble\", function(n){\n\t        for (var i = 2 + (n&1), fact = 1; i <= n; i += 2) {\n\t            fact *= i;\n\t        }\n\t        return fact;\n\t    }).args([\n\t        [ \"*n\", \"integer+\" ]\n\t    ]);\n\n\t    defineFunction(\"multinomial\", function(numbers){\n\t        var div = 1, sum = 0;\n\t        numbers.forEach(function(n){\n\t            if (n < 0) {\n\t                throw new CalcError(\"NUM\");\n\t            }\n\t            sum += n;\n\t            div *= _fact(n);\n\t        });\n\t        return _fact(sum) / div;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ]\n\t    ]);\n\n\t    var _combinations = util.memoize(function (n, k){\n\t        for (var f1 = k + 1, f2 = 1, p1 = 1, p2 = 1; f2 <= n - k; ++f1, ++f2) {\n\t            p1 *= f1;\n\t            p2 *= f2;\n\t        }\n\t        return p1/p2;\n\t    });\n\n\t    defineFunction(\"combin\", _combinations).args([\n\t        [ \"*n\", \"integer++\" ],\n\t        [ \"*k\", [ \"and\", \"integer\", [ \"[between]\", 0, \"$n\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"combina\", function(n, k){\n\t        return _combinations(n + k - 1, n - 1);\n\t    }).args([\n\t        [ \"*n\", \"integer++\" ],\n\t        [ \"*k\", [ \"and\", \"integer\", [ \"[between]\", 1, \"$n\" ] ] ]\n\t    ]);\n\n\t    /* -----[ Statistical functions ]----- */\n\n\t    defineFunction(\"average\", function(numbers){\n\t        var sum = numbers.reduce(function(sum, num){\n\t            return sum + num;\n\t        }, 0);\n\t        return sum / numbers.length;\n\t    }).args([\n\t        // most numeric functions must treat booleans as numbers (1 for TRUE\n\t        // and 0 for FALSE), but AVERAGE shouldn't.\n\t        [ \"numbers\", [ \"collect\", \"number!\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length > 0\", \"DIV/0\" ] ]\n\t    ]);\n\n\t    defineFunction(\"averagea\", function(values){\n\t        var sum = 0, count = 0;\n\t        values.forEach(function(num){\n\t            if (typeof num != \"string\") {\n\t                sum += num;\n\t            }\n\t            ++count;\n\t        });\n\t        return count ? sum / count : new CalcError(\"DIV/0\");\n\t    }).args([\n\t        [ \"values\", [ \"collect\", \"anyvalue\" ] ]\n\t    ]);\n\n\t    function _percentile(numbers, rank) {\n\t        numbers.sort(ascending);\n\t        var n = numbers.length;\n\t        var k = rank | 0, d = rank - k;\n\t        if (k === 0) {\n\t            return numbers[0];\n\t        }\n\t        if (k >= n) {\n\t            return numbers[n - 1];\n\t        }\n\t        --k;\n\t        return numbers[k] + d * (numbers[k + 1] - numbers[k]);\n\t    }\n\n\t    function _percentile_inc(numbers, p){\n\t        // algorithm from https://en.wikipedia.org/wiki/Percentile#Microsoft_Excel_method\n\t        var rank = p * (numbers.length - 1) + 1;\n\t        return _percentile(numbers, rank);\n\t    }\n\n\t    function _percentile_exc(numbers, p){\n\t        // https://en.wikipedia.org/wiki/Percentile#NIST_method\n\t        var rank = p * (numbers.length + 1);\n\t        return _percentile(numbers, rank);\n\t    }\n\n\t    defineFunction(\"percentile.inc\", _percentile_inc).args([\n\t        [ \"numbers\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"p\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"percentile.exc\", _percentile_exc).args([\n\t        [ \"numbers\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"p\", [ \"and\", \"number\", [ \"(between)\", 0, 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"quartile.inc\", function(numbers, quarter){\n\t        return _percentile_inc(numbers, quarter / 4);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"quarter\", [ \"values\", 0, 1, 2, 3, 4 ] ]\n\t    ]);\n\n\t    defineFunction(\"quartile.exc\", function(numbers, quarter){\n\t        return _percentile_exc(numbers, quarter / 4);\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\", 1 ] ],\n\t        [ \"quarter\", [ \"values\", 0, 1, 2, 3, 4 ] ]\n\t    ]);\n\n\t    defineAlias(\"quartile\", \"quartile.inc\");\n\t    defineAlias(\"percentile\", \"percentile.inc\");\n\n\t    var AGGREGATE_FUNCS = [\n\t        \"AVERAGE\", \"COUNT\", \"COUNTA\", \"MAX\", \"MIN\", \"PRODUCT\",\n\t        \"STDEV.S\", \"STDEV.P\", \"SUM\", \"VAR.S\", \"VAR.P\", \"MEDIAN\",\n\t        \"MODE.SNGL\", \"LARGE\", \"SMALL\", \"PERCENTILE.INC\",\n\t        \"QUARTILE.INC\", \"PERCENTILE.EXC\", \"QUARTILE.EXC\"\n\t    ];\n\n\t    function fetchValuesForAggregate(self, args, options) {\n\t        var values = [];\n\t        var opt_ignore_hidden_rows = 1;\n\t        var opt_ignore_errors = 2;\n\t        var opt_use_aggregates = 4;\n\t        (function fetchValues(args) {\n\t            if (args instanceof Ref) {\n\t                self.getRefCells(args, true).forEach(function(cell){\n\t                    var value = cell.value;\n\t                    if ((options & opt_ignore_hidden_rows) && cell.hidden) {\n\t                        return;\n\t                    }\n\t                    if (cell.formula) {\n\t                        // XXX: formula.print is fast, but still, can't we do any better here?\n\t                        //      perhaps access the input string directly somehow?\n\t                        var str = cell.formula.print(cell.row, cell.col);\n\t                        if (/^\\s*(?:aggregate|subtotal)\\s*\\(/i.test(str)) {\n\t                            if (!(options & opt_use_aggregates)) {\n\t                                return;\n\t                            }\n\t                        }\n\t                    }\n\t                    if ((options & opt_ignore_errors) && value instanceof CalcError) {\n\t                        return;\n\t                    }\n\t                    if (typeof value == \"number\" || value instanceof CalcError) {\n\t                        values.push(value);\n\t                    }\n\t                });\n\t            } else if (Array.isArray(args)) {\n\t                for (var i = 0; i < args.length; ++i) {\n\t                    fetchValues(args[i]);\n\t                }\n\t            } else if (args instanceof Matrix) {\n\t                args.each(fetchValues);\n\t            } else if (typeof args == \"number\") {\n\t                values.push(args);\n\t            } else if (args instanceof CalcError && !(options & opt_ignore_errors)) {\n\t                values.push(args);\n\t            }\n\t        })(args);\n\t        return values;\n\t    }\n\n\t    // AGGREGATE function\n\t    //\n\t    // https://support.office.com/en-SG/article/aggregate-function-c8caed56-07df-4aeb-9741-23693ffbe525\n\t    //\n\t    // we can only partially type-check this function.  also, we need to use the async version in\n\t    // order to resolve references and delegate values to the function to aggregate.\n\t    defineFunction(\"aggregate\", function(callback, funcId, options, args){\n\t        // options is a bit field.  that makes sense; it's the documentation which doesn't.\n\t        var self = this;\n\t        self.resolveCells(args, function(){\n\t            var values;\n\t            if (funcId > 12) {\n\t                // \"array form\"\n\t                values = fetchValuesForAggregate(self, args[0], options);\n\t                var k = args[1];\n\t                if (k instanceof CellRef) {\n\t                    k = self.getRefData(k);\n\t                }\n\t                if (typeof k != \"number\") {\n\t                    return callback(new CalcError(\"VALUE\"));\n\t                }\n\t            } else {\n\t                values = fetchValuesForAggregate(self, args, options);\n\t            }\n\t            self.func(AGGREGATE_FUNCS[funcId - 1], callback, values);\n\t        });\n\t    }).argsAsync([\n\t        [ \"funcId\", [ \"values\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\n\t                      11, 12, 13, 14, 15, 16, 17, 18, 19 ] ],\n\t        [ \"options\", [ \"or\",\n\t                       [ \"null\", 0 ],\n\t                       [ \"values\", 0, 1, 2, 3, 4, 5, 6, 7  ] ] ],\n\t        [ \"args\", \"rest\" ]\n\t    ]);\n\n\t    defineFunction(\"subtotal\", function(callback, funcId){\n\t        var self = this;\n\t        var ignoreHidden = funcId > 100;\n\t        if (ignoreHidden) {\n\t            funcId -= 100;\n\t        }\n\t        var args = [];\n\t        for (var i = 2; i < arguments.length; ++i) {\n\t            args.push(arguments[i]);\n\t        }\n\t        self.resolveCells(args, function(){\n\t            var values = fetchValuesForAggregate(self, args, ignoreHidden ? 1 : 0);\n\t            self.func(AGGREGATE_FUNCS[funcId - 1], callback, values);\n\t        });\n\t    }).argsAsync([\n\t        [ \"funcId\", [ \"values\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\n\t                      101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111 ] ],\n\t        [ \"+\", [ \"ref\", [ \"or\", \"ref\", \"#matrix\" ] ] ]\n\t    ]);\n\n\t    // https://support.office.com/en-sg/article/AVEDEV-function-ec78fa01-4755-466c-9a2b-0c4f9eacaf6d\n\t    defineFunction(\"avedev\", function(numbers){\n\t        var avg = numbers.reduce(function(sum, num){\n\t            return sum + num;\n\t        }, 0) / numbers.length;\n\t        return numbers.reduce(function(sum, num){\n\t            return sum + Math.abs(num - avg);\n\t        }, 0) / numbers.length;\n\t    }).args([\n\t        [ \"numbers\", [ \"collect\", \"number\" ] ],\n\t        [ \"?\", [ \"assert\", \"$numbers.length >= 2\", \"NUM\" ] ]\n\t    ]);\n\n\t    function _binom_dist(x, n, p, cumulative) {\n\t        if (!cumulative) {\n\t            return _combinations(n, x) * Math.pow(p, x) * Math.pow(1-p, n-x);\n\t        } else {\n\t            var sum = 0;\n\t            for (var j = 0; j <= x; ++j) {\n\t                sum += _combinations(n, j) * Math.pow(p, j) * Math.pow(1-p, n-j);\n\t            }\n\t            return sum;\n\t        }\n\t    }\n\n\t    defineFunction(\"binom.dist\", _binom_dist).args([\n\t        [ \"successes\", \"integer+\" ],\n\t        [ \"trials\", [ \"and\", \"integer\", [ \"assert\", \"$trials >= $successes\" ] ] ],\n\t        [ \"probability\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineAlias(\"binomdist\", \"binom.dist\");\n\n\t    defineFunction(\"binom.inv\", function(n, p, alpha){\n\t        // XXX: could a binary search be faster?\n\t        for (var x = 0; x <= n; ++x) {\n\t            if (_binom_dist(x, n, p, true) >= alpha) {\n\t                return x;\n\t            }\n\t        }\n\t        return new CalcError(\"N/A\"); // XXX: is this right?\n\t    }).args([\n\t        [ \"trials\", \"integer+\" ],\n\t        [ \"probability\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"alpha\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ]\n\t    ]);\n\n\t    defineAlias(\"critbinom\", \"binom.inv\");\n\n\t    defineFunction(\"binom.dist.range\", function(n, p, s, s2){\n\t        var sum = 0;\n\t        for (var k = s; k <= s2; ++k) {\n\t            sum += _combinations(n, k) * Math.pow(p, k) * Math.pow(1-p, n-k);\n\t        }\n\t        return sum;\n\t    }).args([\n\t        [ \"trials\", \"integer+\" ],\n\t        [ \"probability\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"successes_min\", [ \"and\", \"integer\", [ \"[between]\", 0, \"$trials\" ] ] ],\n\t        [ \"successes_max\", [ \"or\",\n\t                             [ \"and\", \"integer\",\n\t                               [ \"[between]\", \"$successes_min\", \"$trials\" ] ],\n\t                             [ \"null\", \"$successes_min\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"negbinom.dist\", function(x, k, p, cumulative){\n\t        if (cumulative) {\n\t            var sum = 0;\n\t            while (x >= 0) {\n\t                sum += _combinations(x+k-1, x) * Math.pow(p, k) * Math.pow(1-p, x);\n\t                x--;\n\t            }\n\t            return sum;\n\t        }\n\t        return _combinations(x+k-1, x) * Math.pow(p, k) * Math.pow(1-p, x);\n\t    }).args([\n\t        [ \"number_f\", \"integer+\" ],\n\t        [ \"number_s\", \"integer+\" ],\n\t        [ \"probability_s\", [ \"and\", \"number\", [ \"[between]\", 0, 1 ] ] ],\n\t        [ \"cumulative\", \"logical\" ]\n\t    ]);\n\n\t    defineAlias(\"negbinomdist\", \"negbinom.dist\");\n\n\t    /* -----[ lookup functions ]----- */\n\n\t    defineFunction(\"address\", function(row, col, abs, a1, sheet){\n\t        // by some lucky coincidence, we get the corret `rel` value by just subtracting 1 from the\n\t        // abs argument\n\t        var cell = new CellRef(row - 1, col - 1, abs - 1);\n\t        if (sheet) {\n\t            cell.setSheet(sheet, true);\n\t        }\n\t        return a1 ? cell.print(0, 0) : cell.print();\n\t    }).args([\n\t        [ \"row\", \"integer++\" ],\n\t        [ \"col\", \"integer++\" ],\n\t        [ \"abs\", [ \"or\", [ \"null\", 1 ], [ \"values\", 1, 2, 3, 4 ]]],\n\t        [ \"a1\", [ \"or\", [ \"null\", true ], \"logical\" ]],\n\t        [ \"sheet\", [ \"or\", \"null\", \"string\" ]]\n\t    ]);\n\n\t    defineFunction(\"areas\", function(ref){\n\t        var count = 0;\n\t        (function loop(x){\n\t            if (x instanceof CellRef || x instanceof RangeRef) {\n\t                count++;\n\t            } else if (x instanceof UnionRef) {\n\t                x.refs.forEach(loop);\n\t            }\n\t            // XXX: NameRef if we add support\n\t        })(ref);\n\t        return count;\n\t    }).args([\n\t        [ \"ref\", \"ref\" ]\n\t    ]);\n\n\t    defineFunction(\"choose\", function(index, args){\n\t        if (index > args.length) {\n\t            return new CalcError(\"N/A\");\n\t        } else {\n\t            return args[index - 1];\n\t        }\n\t    }).args([\n\t        [ \"*index\", \"integer\" ],\n\t        [ \"+\", [ \"value\", \"anything\" ] ]\n\t    ]);\n\n\t    defineFunction(\"column\", function(ref){\n\t        if (!ref) {\n\t            return this.formula.col + 1;\n\t        }\n\t        if (ref instanceof CellRef) {\n\t            return ref.col + 1;\n\t        }\n\t        return this.asMatrix(ref).mapCol(function(col){\n\t            return col + ref.topLeft.col + 1;\n\t        });\n\t    }).args([\n\t        [ \"ref\", [ \"or\", \"area\", \"null\" ]]\n\t    ]);\n\n\t    defineFunction(\"columns\", function(m){\n\t        return m instanceof Ref ? m.width() : m.width;\n\t    }).args([\n\t        [ \"ref\", [ \"or\", \"area\", \"#matrix\" ] ]\n\t    ]);\n\n\t    defineFunction(\"formulatext\", function(ref){\n\t        var cell = this.getRefCells(ref)[0]; // XXX: overkill, but oh well.\n\t        if (!cell.formula) {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t        return cell.formula.print(cell.row, cell.col);\n\t    }).args([\n\t        [ \"ref\", \"ref\" ]\n\t    ]);\n\n\t    defineFunction(\"hlookup\", function(value, m, row, approx){\n\t        var resultCol = null;\n\t        m.eachCol(function(col){\n\t            var data = m.get(0, col);\n\t            if (approx) {\n\t                if (data > value) {\n\t                    return true;\n\t                }\n\t                resultCol = col;\n\t            } else if (data === value) {\n\t                resultCol = col;\n\t                return true;\n\t            }\n\t        });\n\t        if (resultCol == null) {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t        return m.get(row - 1, resultCol);\n\t    }).args([\n\t        [ \"value\", \"anyvalue\" ],\n\t        [ \"range\", \"matrix\" ],\n\t        [ \"row\", \"integer++\" ],\n\t        [ \"approx\", [ \"or\", \"logical\", [ \"null\", true ]]]\n\t    ]);\n\n\t    defineFunction(\"index\", function(callback, ref, row, col, areanum){\n\t        var self = this;\n\t        if (ref instanceof UnionRef) {\n\t            ref = ref.refs[areanum - 1];\n\t        }\n\t        if ((!row && !col) || !ref) {\n\t            return callback(new CalcError(\"N/A\"));\n\t        }\n\t        if (ref instanceof CellRef) {\n\t            ref = ref.toRangeRef();\n\t        }\n\t        if (ref instanceof RangeRef) {\n\t            if (row && col) {\n\t                if (col > ref.width() || row > ref.height()) {\n\t                    return callback(new CalcError(\"REF\"));\n\t                }\n\t                // fetching a single cell\n\t                var cell = ref.toCell(row - 1, col - 1);\n\t                self.resolveCells([ cell ], function(){\n\t                    callback(self.getRefData(cell));\n\t                });\n\t                return;\n\t            }\n\t            if (!row) {\n\t                // fetch a full column\n\t                var colRange = ref.toColumn(col - 1);\n\t                self.resolveCells([ colRange ], function(){\n\t                    callback(self.asMatrix(colRange));\n\t                });\n\t                return;\n\t            }\n\t            if (!col) {\n\t                // fetch a full row\n\t                var rowRange = ref.toRow(row - 1);\n\t                self.resolveCells([ rowRange ], function(){\n\t                    callback(self.asMatrix(rowRange));\n\t                });\n\t                return;\n\t            }\n\t        }\n\t        else if (ref instanceof Matrix) {\n\t            if (ref.width > 1 && ref.height > 1) {\n\t                if (row && col) {\n\t                    return callback(ref.get(row - 1, col - 1));\n\t                }\n\t                if (!row) {\n\t                    return callback(ref.mapRow(function(row){\n\t                        return ref.get(row, col - 1);\n\t                    }));\n\t                }\n\t                if (!col) {\n\t                    return callback(ref.mapCol(function(col){\n\t                        return ref.get(row - 1, col);\n\t                    }));\n\t                }\n\t            }\n\t            if (ref.width == 1) {\n\t                return callback(ref.get(row - 1, 0));\n\t            }\n\t            if (ref.height == 1) {\n\t                return callback(ref.get(0, col - 1));\n\t            }\n\t        }\n\t        else {\n\t            callback(new CalcError(\"REF\"));\n\t        }\n\t    }).argsAsync([\n\t        [ \"range\", [ \"or\", \"ref\", \"matrix\" ] ],\n\t        [ \"row\", [ \"or\", \"integer+\", \"null\" ] ],\n\t        [ \"col\", [ \"or\", \"integer+\", \"null\" ] ],\n\t        [ \"areanum\", [ \"or\", \"integer++\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"indirect\", function(thing){\n\t        try {\n\t            // XXX: does more work than needed.  we could go for parseReference, but that one\n\t            // doesn't (yet?) support \"SheetName!\" prefix.\n\t            var f = this.formula;\n\t            var exp = calc.parseFormula(f.sheet, f.row, f.col, thing);\n\t            var ref = exp.ast;\n\t            if (ref instanceof NameRef) {\n\t                ref = this.ss.nameValue(ref, f.sheet, f.row, f.col);\n\t            }\n\t            if (!(ref instanceof Ref)) {\n\t                throw 1;\n\t            }\n\t            return ref.absolute(f.row, f.col);\n\t        } catch(ex) {\n\t            return new CalcError(\"REF\");\n\t        }\n\t    }).args([\n\t        [ \"thing\", \"string\" ]\n\t    ]);\n\n\t    // XXX: LOOKUP.  seems to be deprecated in favor of HLOOKUP/VLOOKUP\n\n\t    // XXX: double-check this one.\n\t    defineFunction(\"match\", function(val, m, type){\n\t        var index = 1, cmp;\n\t        if (type === 0) {\n\t            cmp = parseCriteria(val);\n\t        } else if (type === -1) {\n\t            cmp = parseCriteria(\"<=\" + val);\n\t        } else if (type === 1) {\n\t            cmp = parseCriteria(\">=\" + val);\n\t        }\n\t        if (m.each(function(el){\n\t            if (el != null && cmp(el)) {\n\t                if (type !== 0 && val != el) {\n\t                    --index;\n\t                }\n\t                return true;\n\t            }\n\t            index++;\n\t        }, true) && index > 0) {\n\t            return index;\n\t        } else {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t    }).args([\n\t        [ \"value\", \"anyvalue\" ],\n\t        [ \"range\", \"matrix\" ],\n\t        [ \"type\", [ \"or\",\n\t                    [ \"values\", -1, 0, 1 ],\n\t                    [ \"null\", 1 ]]]\n\t    ]);\n\n\t    defineFunction(\"offset\", function(ref, rows, cols, height, width){\n\t        var topLeft = (ref instanceof CellRef ? ref : ref.topLeft).clone();\n\t        topLeft.row += rows;\n\t        topLeft.col += cols;\n\t        if (topLeft.row < 0 || topLeft.col < 0) {\n\t            return new CalcError(\"VALUE\");\n\t        }\n\t        if (height > 1 || width > 1) {\n\t            return new RangeRef(topLeft, new CellRef(topLeft.row + height - 1,\n\t                                                     topLeft.col + width - 1))\n\t                .setSheet(ref.sheet, ref.hasSheet());\n\t        }\n\t        return topLeft;\n\t    }).args([\n\t        [ \"ref\", \"area\" ],\n\t        [ \"*rows\", \"integer\" ],\n\t        [ \"*cols\", \"integer\" ],\n\t        [ \"*height\", [ \"or\", \"integer++\", [ \"null\", \"$ref.height()\" ]]],\n\t        [ \"*width\", [ \"or\", \"integer++\", [ \"null\", \"$ref.width()\" ]]]\n\t    ]);\n\n\t    defineFunction(\"row\", function(ref){\n\t        if (!ref) {\n\t            return this.formula.row + 1;\n\t        }\n\t        if (ref instanceof CellRef) {\n\t            return ref.row + 1;\n\t        }\n\t        return this.asMatrix(ref).mapRow(function(row){\n\t            return row + ref.topLeft.row + 1;\n\t        });\n\t    }).args([\n\t        [ \"ref\", [ \"or\", \"area\", \"null\" ]]\n\t    ]);\n\n\t    defineFunction(\"rows\", function(m){\n\t        return m instanceof Ref ? m.height() : m.height;\n\t    }).args([\n\t        [ \"ref\", [ \"or\", \"area\", \"#matrix\" ] ]\n\t    ]);\n\n\t    defineFunction(\"vlookup\", function(value, m, col, approx){\n\t        var resultRow = null;\n\t        if (typeof value != \"number\") {\n\t            approx = false;\n\t        }\n\t        if (typeof value == \"string\") {\n\t            value = value.toLowerCase();\n\t        }\n\t        m.eachRow(function(row){\n\t            var data = m.get(row, 0);\n\t            if (approx) {\n\t                if (data > value) {\n\t                    return true;\n\t                }\n\t                resultRow = row;\n\t            } else {\n\t                if (typeof data == \"string\") {\n\t                    data = data.toLowerCase();\n\t                }\n\t                if (data === value) {\n\t                    resultRow = row;\n\t                    return true;\n\t                }\n\t            }\n\t        });\n\t        if (resultRow == null) {\n\t            return new CalcError(\"N/A\");\n\t        }\n\t        return m.get(resultRow, col - 1);\n\t    }).args([\n\t        [ \"value\", \"anyvalue\" ],\n\t        [ \"range\", \"matrix\" ],\n\t        [ \"col\", \"integer++\" ],\n\t        [ \"approx\", [ \"or\", \"logical\", [ \"null\", true ]]]\n\t    ]);\n\n\t    /* -----[ Date and time functions ]----- */\n\n\t    defineFunction(\"date\", function(year, month, date){\n\t        return packDate(year, month-1, date);\n\t    }).args([\n\t        [ \"*year\", \"integer\" ],\n\t        [ \"*month\", \"integer\" ],\n\t        [ \"*date\", \"integer\" ]\n\t    ]);\n\n\t    defineFunction(\"day\", function(date){\n\t        return unpackDate(date).date;\n\t    }).args([\n\t        [ \"*date\", \"date\" ]\n\t    ]);\n\n\t    defineFunction(\"month\", function(date){\n\t        return unpackDate(date).month + 1;\n\t    }).args([\n\t        [ \"*date\", \"date\" ]\n\t    ]);\n\n\t    defineFunction(\"year\", function(date){\n\t        return unpackDate(date).year;\n\t    }).args([\n\t        [ \"*date\", \"date\" ]\n\t    ]);\n\n\t    defineFunction(\"weekday\", function(date){\n\t        // XXX: TODO type\n\t        return unpackDate(date).day + 1;\n\t    }).args([\n\t        [ \"*date\", \"date\" ]\n\t    ]);\n\n\t    // https://support.office.com/en-GB/article/WEEKNUM-function-e5c43a03-b4ab-426c-b411-b18c13c75340\n\t    // XXX: this is a mess.\n\t    defineFunction(\"weeknum\", function(date, type){\n\t        var fw = packDate(unpackDate(date).year, 0, 1);\n\t        var sy = unpackDate(fw);\n\t        var diff;\n\t        if (type == 21) {\n\t            // Monday-based weeks, first week is the one containing the first Thursday of the year\n\t            // we want to place in fw and sy the first Thursday\n\t            diff = 3 - (sy.day + 6) % 7;\n\t            if (diff < 0) {\n\t                diff += 7;\n\t            }\n\t            fw += diff;\n\t            sy.date += diff;\n\t            sy.day = 4;         // Thursday.\n\t            type = 1;\n\t        } else {\n\t            if (type == 1) {\n\t                type = 0;\n\t            } else if (type == 2) {\n\t                type = 1;\n\t            } else {\n\t                type = (type - 10) % 7;\n\t            }\n\t            // finally compatible with what we got:\n\t            // type == 0 means week starts on Sunday\n\t            //         1                      Monday\n\t            //         2                      Tuesday\n\t            // ...\n\t        }\n\t        diff = sy.day - type;\n\t        if (diff < 0) {\n\t            diff += 7;\n\t        }\n\t        fw -= diff;\n\t        return Math.ceil((date + 1 - fw) / 7);\n\t    }).args([\n\t        [ \"*date\", \"date\" ],\n\t        [ \"*type\", [ \"or\", [ \"null\", 1 ],\n\t                     [ \"values\", 1, 2, 11, 12, 13, 14, 15, 16, 17, 21 ] ] ]\n\t    ]);\n\n\t    function weeksInYear(year) {\n\t        var d = unpackDate(packDate(year, 0, 1));\n\t        if ((d.day == 4) || (d.day == 3 && runtime.isLeapYear(year))) {\n\t            // long year\n\t            return 53;\n\t        }\n\t        return 52;\n\t    }\n\n\t    defineFunction(\"isoweeknum\", function isoweeknum(date){\n\t        // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_of_a_given_date\n\t        var d = unpackDate(date);\n\t        var dow = d.day || 7;\n\t        var wk = Math.floor((d.ord - dow + 10) / 7);\n\t        if (wk < 1) {\n\t            return weeksInYear(d.year - 1);\n\t        } else if (wk == 53 && wk > weeksInYear(d.year)) {\n\t            return 1;\n\t        }\n\t        return wk;\n\t    }).args([\n\t        [ \"*date\", \"date\" ]\n\t    ]);\n\n\t    defineFunction(\"now\", function(){\n\t        return runtime.dateToSerial(new Date());\n\t    }).args([]);\n\n\t    defineFunction(\"today\", function(){\n\t        return runtime.dateToSerial(new Date()) | 0;\n\t    }).args([]);\n\n\t    defineFunction(\"time\", function(hh, mm, ss){\n\t        return runtime.packTime(hh, mm, ss, 0);\n\t    }).args([\n\t        [ \"*hours\", \"integer\" ],\n\t        [ \"*minutes\", \"integer\" ],\n\t        [ \"*seconds\", \"integer\" ]\n\t    ]);\n\n\t    defineFunction(\"hour\", function(time){\n\t        return runtime.unpackTime(time).hours;\n\t    }).args([\n\t        [ \"*time\", \"datetime\" ]\n\t    ]);\n\n\t    defineFunction(\"minute\", function(time){\n\t        return runtime.unpackTime(time).minutes;\n\t    }).args([\n\t        [ \"*time\", \"datetime\" ]\n\t    ]);\n\n\t    defineFunction(\"second\", function(time){\n\t        return runtime.unpackTime(time).seconds;\n\t    }).args([\n\t        [ \"*time\", \"datetime\" ]\n\t    ]);\n\n\t    defineFunction(\"edate\", function(base, months){\n\t        var d = unpackDate(base);\n\t        var m = d.month + months;\n\t        var y = d.year + Math.floor(m/12);\n\t        m %= 12;\n\t        if (m < 0) {\n\t            m += 12;\n\t        }\n\t        d = Math.min(d.date, daysInMonth(y, m));\n\t        return packDate(y, m, d);\n\t    }).args([\n\t        [ \"*start_date\", \"date\" ],\n\t        [ \"*months\", \"integer\" ]\n\t    ]);\n\n\t    defineFunction(\"eomonth\", function(base, months){\n\t        var d = unpackDate(base);\n\t        var m = d.month + months;\n\t        var y = d.year + Math.floor(m/12);\n\t        m %= 12;\n\t        if (m < 0) {\n\t            m += 12;\n\t        }\n\t        d = daysInMonth(y, m);\n\t        return packDate(y, m, d);\n\t    }).args([\n\t        [ \"*start_date\", \"date\" ],\n\t        [ \"*months\", \"integer\" ]\n\t    ]);\n\n\t    defineFunction(\"workday\", function(date, n, holidays){\n\t        // XXX: the algorithm here is pretty dumb, can we do better?\n\t        var inc = n > 0 ? 1 : -1;\n\t        n = Math.abs(n);\n\t        var dow = unpackDate(date).day;\n\t        while (n > 0) {\n\t            date += inc;\n\t            dow = (dow + inc) % 7;\n\t            if (dow > 0 && dow < 6 && holidays.indexOf(date) < 0) {\n\t                --n;\n\t            }\n\t        }\n\t        return date;\n\t    }).args([\n\t        [ \"start_date\", \"date\" ],\n\t        [ \"days\", \"integer\" ],\n\t        [ \"holidays\", [ \"collect\", \"date\" ] ]\n\t    ]);\n\n\t    defineFunction(\"networkdays\", function(date, end, holidays){\n\t        // XXX: the algorithm here is pretty dumb, can we do better?\n\t        if (date > end) {\n\t            var tmp = date;\n\t            date = end;\n\t            end = tmp;\n\t        }\n\t        var count = 0;\n\t        var dow = unpackDate(date).day;\n\t        while (date <= end) {\n\t            if (dow > 0 && dow < 6 && holidays.indexOf(date) < 0) {\n\t                count++;\n\t            }\n\t            date++;\n\t            dow = (dow + 1) % 7;\n\t        }\n\t        return count;\n\t    }).args([\n\t        [ \"start_date\", \"date\" ],\n\t        [ \"end_date\", \"date\" ],\n\t        [ \"holidays\", [ \"collect\", \"date\" ] ]\n\t    ]);\n\n\t    defineFunction(\"days\", function(start, end){\n\t        return end - start;\n\t    }).args([\n\t        [ \"*start_date\", \"date\" ],\n\t        [ \"*end_date\", \"date\" ]\n\t    ]);\n\n\t    function _days_360(start, end, method) {\n\t        var d1 = unpackDate(start);\n\t        var d2 = unpackDate(end);\n\n\t        // https://en.wikipedia.org/wiki/360-day_calendar\n\t        // humanity is a mess.\n\t        if (method) {\n\t            // EU method\n\t            if (d1.date == 31) {\n\t                d1.date = 30;\n\t            }\n\t            if (d2.date == 31) {\n\t                d2.date = 30;\n\t            }\n\t        } else {\n\t            // US method\n\t            if (d1.month == 1 && d2.month == 1\n\t                && d1.date == daysInMonth(d1.year, 1)\n\t                && d2.date == daysInMonth(d2.year, 1)) {\n\t                d2.date = 30;\n\t            }\n\t            if (d1.date == daysInMonth(d1.year, d1.month)) {\n\t                d1.date = 30;\n\t                if (d2.date == 31) {\n\t                    d2.date = 30;\n\t                }\n\t            } else {\n\t                if (d1.date == 30 && d2.date == 31) {\n\t                    d2.date = 30;\n\t                }\n\t            }\n\t        }\n\n\t        return (360 * (d2.year - d1.year)\n\t                + 30 * (d2.month - d1.month)\n\t                + (d2.date - d1.date));\n\t    }\n\n\t    runtime._days_360 = _days_360;\n\n\t    defineFunction(\"days360\", _days_360).args([\n\t        [ \"*start_date\", \"date\" ],\n\t        [ \"*end_date\", \"date\" ],\n\t        [ \"*method\", [ \"or\", \"logical\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    defineFunction(\"yearfrac\", function(start, end, method){\n\t        switch (method) {\n\t          case 0:\n\t            return _days_360(start, end, false) / 360;\n\t          case 1:\n\t            return (end - start) / daysInYear(unpackDate(start).year);\n\t          case 2:\n\t            return (end - start) / 360;\n\t          case 3:\n\t            return (end - start) / 365;\n\t          case 4:\n\t            return _days_360(start, end, true) / 360;\n\t        }\n\t    }).args([\n\t        [ \"*start_date\", \"date\" ],\n\t        [ \"*end_date\", \"date\" ],\n\t        [ \"*method\", [ \"or\", [ \"null\", 0 ], [ \"values\", 0, 1, 2, 3, 4 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"datevalue\", function(text){\n\t        var date = runtime.parseDate(text);\n\t        if (date) {\n\t            return runtime.dateToSerial(date);\n\t        }\n\t        return new CalcError(\"VALUE\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"timevalue\", function(text){\n\t        var m = text.toLowerCase().match(/(\\d+):(\\d+)(:(\\d+)(\\.(\\d+))?)?\\s*(am?|pm?)?/);\n\t        if (m) {\n\t            var hh = parseFloat(m[1]);\n\t            var mm = parseFloat(m[2]);\n\t            var ss = m[3] ? parseFloat(m[4]) : 0;\n\t            //var ms = m[5] ? parseFloat(m[6]) : 0;\n\t            var ampm = m[7];\n\t            if (ampm && (hh > 12 || hh < 1)) {\n\t                return new CalcError(\"VALUE\");\n\t            }\n\t            if (/^p/.test(ampm)) {\n\t                hh += 12;\n\t            }\n\t            return runtime.packTime(hh, mm, ss, 0);\n\t        }\n\t        return new CalcError(\"VALUE\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    /* -----[ Matrix functions ]----- */\n\n\t    defineFunction(\"mdeterm\", function(m){\n\t        var error = m.each(function(val){\n\t            if (typeof val != \"number\") {\n\t                return new CalcError(\"VALUE\");\n\t            }\n\t        }, true);\n\t        return error || m.determinant();\n\t    }).args([\n\t        [ \"m\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$m.width == $m.height\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"transpose\", function(m){\n\t        return m.transpose();\n\t    }).args([\n\t        [ \"range\", \"matrix\" ]\n\t    ]);\n\n\t    defineFunction(\"mmult\", function(a, b){\n\t        return a.multiply(b);\n\t    }).args([\n\t        [ \"a\", \"matrix\" ],\n\t        [ \"b\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$b.height == $a.width\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"munit\", function(n){\n\t        return new Matrix(this).unit(n);\n\t    }).args([\n\t        [ \"n\", \"integer+\" ]\n\t    ]);\n\n\t    defineFunction(\"minverse\", function(m){\n\t        var error = m.each(function(val){\n\t            if (typeof val != \"number\") {\n\t                return new CalcError(\"VALUE\");\n\t            }\n\t        }, true);\n\t        return error || m.inverse() || new CalcError(\"VALUE\");\n\t    }).args([\n\t        [ \"m\", [ \"and\", \"matrix\",\n\t                 [ \"assert\", \"$m.width == $m.height\" ] ] ]\n\t    ]);\n\n\t    /* -----[ Other ]----- */\n\n\t    defineFunction(\"rand\", function() {\n\t        return Math.random();\n\t    }).args([]);\n\n\t    defineFunction(\"randbetween\", function(min, max){\n\t        return min + Math.floor((max - min + 1) * Math.random());\n\t    }).args([\n\t        [ \"min\", \"integer\" ],\n\t        [ \"max\", [ \"and\", \"integer\", [ \"assert\", \"$max >= $min\" ] ] ]\n\t    ]);\n\n\t    defineFunction(\"true\", function(){\n\t        return true;\n\t    }).args([]);\n\n\t    defineFunction(\"false\", function(){\n\t        return true;\n\t    }).args([]);\n\n\t    defineFunction(\"roman\", function(num){\n\t        return util.arabicToRoman(num).toUpperCase();\n\t    }).args([\n\t        [ \"*number\", \"integer\" ]\n\t    ]);\n\n\t    defineFunction(\"arabic\", function(rom){\n\t        var num = util.romanToArabic(rom);\n\t        return num == null ? new CalcError(\"VALUE\") : num;\n\t    }).args([\n\t        [ \"*roman\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"base\", function(number, radix, minLen){\n\t        var str = number.toString(radix).toUpperCase();\n\t        while (str.length < minLen) {\n\t            str = \"0\" + str;\n\t        }\n\t        return str;\n\t    }).args([\n\t        [ \"*number\", \"integer\" ],\n\t        [ \"*radix\", [ \"and\", \"integer\", [ \"[between]\", 2, 36 ] ] ],\n\t        [ \"*minLen\", [ \"or\", \"integer+\", [ \"null\", 0 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"decimal\", function(text, radix){\n\t        text = text.toUpperCase();\n\t        var val = 0;\n\t        for (var i = 0; i < text.length; ++i) {\n\t            var d = text.charCodeAt(i);\n\t            if (d >= 48 && d <= 57) {\n\t                d -= 48;\n\t            } else if (d >= 65 && d < (55 + radix)) {\n\t                d -= 55;\n\t            } else {\n\t                return new CalcError(\"VALUE\");\n\t            }\n\t            val = val * radix + d;\n\t        }\n\t        return val;\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*radix\", [ \"and\", \"integer\", [ \"[between]\", 2, 36 ] ] ]\n\t    ]);\n\n\t    /* -----[ String functions ]----- */\n\n\t    defineFunction(\"char\", function(code){\n\t        return String.fromCharCode(code);\n\t    }).args([\n\t        [ \"*code\", \"integer+\" ]\n\t    ]);\n\n\t    // From XRegExp\n\t    var RX_NON_PRINTABLE = /[\\0-\\x1F\\x7F-\\x9F\\xAD\\u0378\\u0379\\u037F-\\u0383\\u038B\\u038D\\u03A2\\u0528-\\u0530\\u0557\\u0558\\u0560\\u0588\\u058B-\\u058E\\u0590\\u05C8-\\u05CF\\u05EB-\\u05EF\\u05F5-\\u0605\\u061C\\u061D\\u06DD\\u070E\\u070F\\u074B\\u074C\\u07B2-\\u07BF\\u07FB-\\u07FF\\u082E\\u082F\\u083F\\u085C\\u085D\\u085F-\\u089F\\u08A1\\u08AD-\\u08E3\\u08FF\\u0978\\u0980\\u0984\\u098D\\u098E\\u0991\\u0992\\u09A9\\u09B1\\u09B3-\\u09B5\\u09BA\\u09BB\\u09C5\\u09C6\\u09C9\\u09CA\\u09CF-\\u09D6\\u09D8-\\u09DB\\u09DE\\u09E4\\u09E5\\u09FC-\\u0A00\\u0A04\\u0A0B-\\u0A0E\\u0A11\\u0A12\\u0A29\\u0A31\\u0A34\\u0A37\\u0A3A\\u0A3B\\u0A3D\\u0A43-\\u0A46\\u0A49\\u0A4A\\u0A4E-\\u0A50\\u0A52-\\u0A58\\u0A5D\\u0A5F-\\u0A65\\u0A76-\\u0A80\\u0A84\\u0A8E\\u0A92\\u0AA9\\u0AB1\\u0AB4\\u0ABA\\u0ABB\\u0AC6\\u0ACA\\u0ACE\\u0ACF\\u0AD1-\\u0ADF\\u0AE4\\u0AE5\\u0AF2-\\u0B00\\u0B04\\u0B0D\\u0B0E\\u0B11\\u0B12\\u0B29\\u0B31\\u0B34\\u0B3A\\u0B3B\\u0B45\\u0B46\\u0B49\\u0B4A\\u0B4E-\\u0B55\\u0B58-\\u0B5B\\u0B5E\\u0B64\\u0B65\\u0B78-\\u0B81\\u0B84\\u0B8B-\\u0B8D\\u0B91\\u0B96-\\u0B98\\u0B9B\\u0B9D\\u0BA0-\\u0BA2\\u0BA5-\\u0BA7\\u0BAB-\\u0BAD\\u0BBA-\\u0BBD\\u0BC3-\\u0BC5\\u0BC9\\u0BCE\\u0BCF\\u0BD1-\\u0BD6\\u0BD8-\\u0BE5\\u0BFB-\\u0C00\\u0C04\\u0C0D\\u0C11\\u0C29\\u0C34\\u0C3A-\\u0C3C\\u0C45\\u0C49\\u0C4E-\\u0C54\\u0C57\\u0C5A-\\u0C5F\\u0C64\\u0C65\\u0C70-\\u0C77\\u0C80\\u0C81\\u0C84\\u0C8D\\u0C91\\u0CA9\\u0CB4\\u0CBA\\u0CBB\\u0CC5\\u0CC9\\u0CCE-\\u0CD4\\u0CD7-\\u0CDD\\u0CDF\\u0CE4\\u0CE5\\u0CF0\\u0CF3-\\u0D01\\u0D04\\u0D0D\\u0D11\\u0D3B\\u0D3C\\u0D45\\u0D49\\u0D4F-\\u0D56\\u0D58-\\u0D5F\\u0D64\\u0D65\\u0D76-\\u0D78\\u0D80\\u0D81\\u0D84\\u0D97-\\u0D99\\u0DB2\\u0DBC\\u0DBE\\u0DBF\\u0DC7-\\u0DC9\\u0DCB-\\u0DCE\\u0DD5\\u0DD7\\u0DE0-\\u0DF1\\u0DF5-\\u0E00\\u0E3B-\\u0E3E\\u0E5C-\\u0E80\\u0E83\\u0E85\\u0E86\\u0E89\\u0E8B\\u0E8C\\u0E8E-\\u0E93\\u0E98\\u0EA0\\u0EA4\\u0EA6\\u0EA8\\u0EA9\\u0EAC\\u0EBA\\u0EBE\\u0EBF\\u0EC5\\u0EC7\\u0ECE\\u0ECF\\u0EDA\\u0EDB\\u0EE0-\\u0EFF\\u0F48\\u0F6D-\\u0F70\\u0F98\\u0FBD\\u0FCD\\u0FDB-\\u0FFF\\u10C6\\u10C8-\\u10CC\\u10CE\\u10CF\\u1249\\u124E\\u124F\\u1257\\u1259\\u125E\\u125F\\u1289\\u128E\\u128F\\u12B1\\u12B6\\u12B7\\u12BF\\u12C1\\u12C6\\u12C7\\u12D7\\u1311\\u1316\\u1317\\u135B\\u135C\\u137D-\\u137F\\u139A-\\u139F\\u13F5-\\u13FF\\u169D-\\u169F\\u16F1-\\u16FF\\u170D\\u1715-\\u171F\\u1737-\\u173F\\u1754-\\u175F\\u176D\\u1771\\u1774-\\u177F\\u17DE\\u17DF\\u17EA-\\u17EF\\u17FA-\\u17FF\\u180F\\u181A-\\u181F\\u1878-\\u187F\\u18AB-\\u18AF\\u18F6-\\u18FF\\u191D-\\u191F\\u192C-\\u192F\\u193C-\\u193F\\u1941-\\u1943\\u196E\\u196F\\u1975-\\u197F\\u19AC-\\u19AF\\u19CA-\\u19CF\\u19DB-\\u19DD\\u1A1C\\u1A1D\\u1A5F\\u1A7D\\u1A7E\\u1A8A-\\u1A8F\\u1A9A-\\u1A9F\\u1AAE-\\u1AFF\\u1B4C-\\u1B4F\\u1B7D-\\u1B7F\\u1BF4-\\u1BFB\\u1C38-\\u1C3A\\u1C4A-\\u1C4C\\u1C80-\\u1CBF\\u1CC8-\\u1CCF\\u1CF7-\\u1CFF\\u1DE7-\\u1DFB\\u1F16\\u1F17\\u1F1E\\u1F1F\\u1F46\\u1F47\\u1F4E\\u1F4F\\u1F58\\u1F5A\\u1F5C\\u1F5E\\u1F7E\\u1F7F\\u1FB5\\u1FC5\\u1FD4\\u1FD5\\u1FDC\\u1FF0\\u1FF1\\u1FF5\\u1FFF\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u206F\\u2072\\u2073\\u208F\\u209D-\\u209F\\u20BB-\\u20CF\\u20F1-\\u20FF\\u218A-\\u218F\\u23F4-\\u23FF\\u2427-\\u243F\\u244B-\\u245F\\u2700\\u2B4D-\\u2B4F\\u2B5A-\\u2BFF\\u2C2F\\u2C5F\\u2CF4-\\u2CF8\\u2D26\\u2D28-\\u2D2C\\u2D2E\\u2D2F\\u2D68-\\u2D6E\\u2D71-\\u2D7E\\u2D97-\\u2D9F\\u2DA7\\u2DAF\\u2DB7\\u2DBF\\u2DC7\\u2DCF\\u2DD7\\u2DDF\\u2E3C-\\u2E7F\\u2E9A\\u2EF4-\\u2EFF\\u2FD6-\\u2FEF\\u2FFC-\\u2FFF\\u3040\\u3097\\u3098\\u3100-\\u3104\\u312E-\\u3130\\u318F\\u31BB-\\u31BF\\u31E4-\\u31EF\\u321F\\u32FF\\u4DB6-\\u4DBF\\u9FCD-\\u9FFF\\uA48D-\\uA48F\\uA4C7-\\uA4CF\\uA62C-\\uA63F\\uA698-\\uA69E\\uA6F8-\\uA6FF\\uA78F\\uA794-\\uA79F\\uA7AB-\\uA7F7\\uA82C-\\uA82F\\uA83A-\\uA83F\\uA878-\\uA87F\\uA8C5-\\uA8CD\\uA8DA-\\uA8DF\\uA8FC-\\uA8FF\\uA954-\\uA95E\\uA97D-\\uA97F\\uA9CE\\uA9DA-\\uA9DD\\uA9E0-\\uA9FF\\uAA37-\\uAA3F\\uAA4E\\uAA4F\\uAA5A\\uAA5B\\uAA7C-\\uAA7F\\uAAC3-\\uAADA\\uAAF7-\\uAB00\\uAB07\\uAB08\\uAB0F\\uAB10\\uAB17-\\uAB1F\\uAB27\\uAB2F-\\uABBF\\uABEE\\uABEF\\uABFA-\\uABFF\\uD7A4-\\uD7AF\\uD7C7-\\uD7CA\\uD7FC-\\uF8FF\\uFA6E\\uFA6F\\uFADA-\\uFAFF\\uFB07-\\uFB12\\uFB18-\\uFB1C\\uFB37\\uFB3D\\uFB3F\\uFB42\\uFB45\\uFBC2-\\uFBD2\\uFD40-\\uFD4F\\uFD90\\uFD91\\uFDC8-\\uFDEF\\uFDFE\\uFDFF\\uFE1A-\\uFE1F\\uFE27-\\uFE2F\\uFE53\\uFE67\\uFE6C-\\uFE6F\\uFE75\\uFEFD-\\uFF00\\uFFBF-\\uFFC1\\uFFC8\\uFFC9\\uFFD0\\uFFD1\\uFFD8\\uFFD9\\uFFDD-\\uFFDF\\uFFE7\\uFFEF-\\uFFFB\\uFFFE\\uFFFF]/g;\n\n\t    defineFunction(\"clean\", function(text){\n\t        return text.replace(RX_NON_PRINTABLE, \"\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"code\", function(text){\n\t        return text.charAt(0);\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineAlias(\"unichar\", \"char\");\n\t    defineAlias(\"unicode\", \"code\");\n\n\t    defineFunction(\"concatenate\", function(args){\n\t        var out = \"\";\n\t        for (var i = 0; i < args.length; ++i) {\n\t            out += args[i];\n\t        }\n\t        return out;\n\t    }).args([\n\t        [ \"+\",\n\t          [ \"*text\", \"string\" ] ]\n\t    ]);\n\n\t    defineFunction(\"dollar\", function(number, decimals){\n\t        var format = \"$#,##0DECIMALS;($#,##0DECIMALS)\";\n\t        var dec = \"\";\n\t        var denomitator = 1;\n\n\t        while (decimals-- > 0) {\n\t          dec += \"0\";\n\t        }\n\n\t        while (++decimals < 0) {\n\t          denomitator *= 10;\n\t        }\n\n\t        if (dec !== \"\") {\n\t          dec = \".\" + dec;\n\t        } else if (denomitator !== 1) {\n\t            number = Math.round(number / denomitator) * denomitator;\n\t        }\n\n\t        format = format.replace(/DECIMALS/g, dec);\n\n\t        return spreadsheet.formatting.text(number, format);\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*decimals\", [ \"or\", \"integer\", [ \"null\", 2 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"exact\", function(a, b){\n\t        return a === b;\n\t    }).args([\n\t        [ \"*text1\", \"string\" ],\n\t        [ \"*text2\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"find\", function(substring, string, start){\n\t        var pos = string.indexOf(substring, start - 1);\n\t        return pos < 0 ? new CalcError(\"VALUE\") : pos + 1;\n\t    }).args([\n\t        [ \"*substring\", \"string\" ],\n\t        [ \"*string\", \"string\" ],\n\t        [ \"*start\", [ \"or\", \"integer++\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"fixed\", function(number, decimals, noCommas){\n\t        var scale = Math.pow(10, decimals);\n\t        number = Math.round(number * scale) / scale;\n\t        var format = noCommas ? \"0\" : \"#,##0\";\n\t        if (decimals > 0) {\n\t            format += \".\";\n\t            while (decimals-- > 0) { format += \"0\"; }\n\t        }\n\t        return spreadsheet.formatting.text(number, format);\n\t    }).args([\n\t        [ \"*number\", \"number\" ],\n\t        [ \"*decimals\", [ \"or\", \"integer\", [ \"null\", 2 ] ] ],\n\t        [ \"*noCommas\", [ \"or\", \"boolean\", [ \"null\", false ] ] ]\n\t    ]);\n\n\t    defineFunction(\"left\", function(text, length){\n\t        return text.substr(0, length);\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*length\", [ \"or\", \"integer+\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"right\", function(text, length){\n\t        return text.substr(-length);\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*length\", [ \"or\", \"integer+\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"len\", function(text){\n\t        return text.length;\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"lower\", function(text){\n\t        return text.toLowerCase();\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"upper\", function(text){\n\t        return text.toUpperCase();\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"ltrim\", function(text){\n\t        return text.replace(/^\\s+/, \"\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"rtrim\", function(text){\n\t        return text.replace(/\\s+$/, \"\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"trim\", function(text){\n\t        return text.replace(/^\\s+|\\s+$/, \"\");\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"mid\", function(text, start, length){\n\t        return text.substr(start - 1, length);\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*start\", \"integer++\" ],\n\t        [ \"*length\", \"integer+\" ]\n\t    ]);\n\n\t    defineFunction(\"proper\", function(text){\n\t        return text.toLowerCase().replace(/\\b./g, function(s){\n\t            return s.toUpperCase();\n\t        });\n\t    }).args([\n\t        [ \"*text\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"replace\", function(text, start, length, newText){\n\t        return text.substr(0, --start) + newText + text.substr(start + length);\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*start\", \"integer++\" ],\n\t        [ \"*length\", \"integer+\" ],\n\t        [ \"*newText\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"rept\", function(text, number){\n\t        var out = \"\";\n\t        while (number-- > 0) { out += text; }\n\t        return out;\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*number\", \"integer+\" ]\n\t    ]);\n\n\t    defineFunction(\"search\", function(substring, string, start){\n\t        var pos = string.toLowerCase().indexOf(substring.toLowerCase(), start - 1);\n\t        return pos < 0 ? new CalcError(\"VALUE\") : pos + 1;\n\t    }).args([\n\t        [ \"*substring\", \"string\" ],\n\t        [ \"*string\", \"string\" ],\n\t        [ \"*start\", [ \"or\", \"integer++\", [ \"null\", 1 ] ] ]\n\t    ]);\n\n\t    defineFunction(\"substitute\", function(text, oldText, newText, nth){\n\t        if (oldText === newText) {\n\t            return text;\n\t        }\n\t        var a = text.split(oldText);\n\t        if (nth == null) {\n\t            return a.join(newText);\n\t        }\n\t        text = \"\";\n\t        nth--;\n\t        for (var i = 0; i < a.length; ++i) {\n\t            text += a[i];\n\t            if (i < a.length - 1) {\n\t                if (i === nth) {\n\t                    text += newText;\n\t                } else {\n\t                    text += oldText;\n\t                }\n\t            }\n\t        }\n\t        return text;\n\t    }).args([\n\t        [ \"*text\", \"string\" ],\n\t        [ \"*oldText\", \"string\" ],\n\t        [ \"*newText\", \"string\" ],\n\t        [ \"*nth\", [ \"or\", \"integer++\", \"null\" ] ]\n\t    ]);\n\n\t    defineFunction(\"t\", function(value){\n\t        return typeof value == \"string\" ? value : \"\";\n\t    }).args([\n\t        [ \"*value\", \"anyvalue\" ]\n\t    ]);\n\n\t    defineFunction(\"text\", function(value, format){\n\t        return spreadsheet.formatting.text(value, format);\n\t    }).args([\n\t        [ \"*value\", \"anyvalue\" ],\n\t        [ \"*format\", \"string\" ]\n\t    ]);\n\n\t    defineFunction(\"value\", function(value){\n\t        if (typeof value == \"number\") {\n\t            return value;\n\t        }\n\t        if (typeof value == \"boolean\") {\n\t            return +value;\n\t        }\n\t        // XXX: this is dirty.  we need it so we can parse i.e. \"$12,345.50\"\n\t        value = (value+\"\").replace(/[$€,]/g, \"\");\n\t        value = parseFloat(value);\n\t        return isNaN(value) ? new CalcError(\"VALUE\") : value;\n\t    }).args([\n\t        [ \"*value\", \"anyvalue\" ]\n\t    ]);\n\n\t    function Hyperlink(link, text) {\n\t        this.link = link;\n\t        this.text = text;\n\t    }\n\t    Hyperlink.prototype.toString = function() {\n\t        return this.text;\n\t    };\n\n\t    defineFunction(\"hyperlink\", function(link, text){\n\t        return new Hyperlink(link, text);\n\t    }).args([\n\t        [ \"*link\", \"string\" ],\n\t        [ \"*text\", [ \"or\", \"string\", [ \"null\", \"$link\" ] ] ]\n\t    ]);\n\n\t    //// other misc functions\n\n\t    defineFunction(\"iferror\", function(value, valueIfError){\n\t        return value instanceof CalcError ? valueIfError : value;\n\t    }).args([\n\t        [ \"*value\", \"forced!\" ],\n\t        [ \"*value_if_error\", \"anyvalue!\" ]\n\t    ]);\n\n\t    //// utils\n\n\t    var parseCriteria = (function(){\n\t        var RXCACHE = Object.create(null);\n\n\t        function makeComparator(cmp, x) {\n\t            if (typeof x == \"string\") {\n\t                var num = parseFloat(x);\n\t                if (!isNaN(num) && num == x) {\n\t                    x = num;\n\t                }\n\t            }\n\t            return function(a) {\n\t                var b = x;\n\t                if (typeof a == \"string\" && typeof b == \"string\") {\n\t                    a = a.toLowerCase();\n\t                    b = b.toLowerCase();\n\t                }\n\t                return cmp(a, b);\n\t            };\n\t        }\n\n\t        function lc(a) {\n\t            var num, str;\n\t            if (typeof a == \"string\") {\n\t                a = a.toLowerCase();\n\t            }\n\t            if (/^[0-9.]+%$/.test(a)) {\n\t                str = a.substr(0, a.length - 1);\n\t                num = parseFloat(str);\n\t                if (!isNaN(num) && num == str) {\n\t                    a = num / 100;\n\t                }\n\t            } else if (/^[0-9.]+$/.test(a)) {\n\t                num = parseFloat(a);\n\t                if (!isNaN(num) && num == a) {\n\t                    a = num;\n\t                }\n\t            }\n\t            return a;\n\t        }\n\n\t        function compLT(a, b) { return lc(a) < lc(b); }\n\t        function compLTE(a, b) { return lc(a) <= lc(b); }\n\t        function compGT(a, b) { return lc(a) > lc(b); }\n\t        function compGTE(a, b) { return lc(a) >= lc(b); }\n\t        function compNE(a, b) { return !compEQ(a, b); }\n\t        function compEQ(a, b) {\n\t            if (b instanceof RegExp) {\n\t                return b.test(a);\n\t            }\n\t            if (typeof a == \"string\" || typeof b == \"string\") {\n\t                // if either one is string, make sure both are strings\n\t                a = String(a);\n\t                b = String(b);\n\t            }\n\t            return lc(a) == lc(b);\n\t        }\n\n\t        return function(cmp) {\n\t            if (typeof cmp == \"function\") {\n\t                return cmp;\n\t            }\n\t            var m;\n\t            if ((m = /^=(.*)$/.exec(cmp))) {\n\t                return makeComparator(compEQ, m[1]);\n\t            }\n\t            if ((m = /^<>(.*)$/.exec(cmp))) {\n\t                return makeComparator(compNE, m[1]);\n\t            }\n\t            if ((m = /^<=(.*)$/.exec(cmp))) {\n\t                return makeComparator(compLTE, m[1]);\n\t            }\n\t            if ((m = /^<(.*)$/.exec(cmp))) {\n\t                return makeComparator(compLT, m[1]);\n\t            }\n\t            if ((m = /^>=(.*)$/.exec(cmp))) {\n\t                return makeComparator(compGTE, m[1]);\n\t            }\n\t            if ((m = /^>(.*)$/.exec(cmp))) {\n\t                return makeComparator(compGT, m[1]);\n\t            }\n\t            if (/[?*]/.exec(cmp)) {\n\t                // has wildchars\n\t                var rx = RXCACHE[cmp];\n\t                if (!rx) {\n\t                    rx = cmp.replace(/(~\\?|~\\*|[\\]({\\+\\.\\|\\^\\$\\\\})\\[]|[?*])/g, function(s){\n\t                        switch (s) {\n\t                          case \"~?\" : return \"\\\\?\";\n\t                          case \"~*\" : return \"\\\\*\";\n\t                          case \"?\"  : return \".\";\n\t                          case \"*\"  : return \".*\";\n\t                          default   : return \"\\\\\" + s;\n\t                        }\n\t                    });\n\t                    rx = RXCACHE[cmp] = new RegExp(\"^\" + rx + \"$\", \"i\");\n\t                }\n\t                return makeComparator(compEQ, rx);\n\t            }\n\t            return makeComparator(compEQ, cmp);\n\t        };\n\t    })();\n\n\t    function numericPredicate(val) {\n\t        return typeof val == \"number\"\n\t            || typeof val == \"boolean\"\n\t            || val == null\n\t            || val === \"\";\n\t    }\n\n\t    function ascending(a, b) {\n\t        return a === b ? 0 : a < b ? -1 : 1;\n\t    }\n\n\t    function descending(a, b) {\n\t        return a === b ? 0 : a < b ? 1 : -1;\n\t    }\n\n\t    // var m = new Matrix();\n\t    // m.data = [[1, 2, 3], [4, 1, 6], [7, 8, 9]];\n\t    // //m.data = [[0, 2, 1], [2, 6, 1], [1, 1, 4]];\n\t    // //m.data = [[1,4,1,1], [1,4,0,1], [2,3,1,2], [3,2,6,4]];\n\t    // m.width = m.height = 3;\n\t    // var x = m.inverse();\n\t    // x.dump();\n\n\t}, __webpack_require__(3));\n\n\n/***/ })\n\n/******/ });"],"sourceRoot":""}